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.Assembly;
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 AssemblyXpp3Reader.
38   * 
39   * @version $Revision$ $Date$
40   */
41  @SuppressWarnings( "all" )
42  public class AssemblyXpp3Reader
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 parseAssembly.
790      * 
791      * @param parser
792      * @param strict
793      * @throws IOException
794      * @throws XmlPullParserException
795      * @return Assembly
796      */
797     private Assembly parseAssembly( XmlPullParser parser, boolean strict )
798         throws IOException, XmlPullParserException
799     {
800         String tagName = parser.getName();
801         Assembly assembly = new Assembly();
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, "id", null, parsed ) )
824             {
825                 assembly.setId( getTrimmedValue( parser.nextText() ) );
826             }
827             else if ( checkFieldWithDuplicate( parser, "formats", null, parsed ) )
828             {
829                 java.util.List formats = new java.util.ArrayList/*<String>*/();
830                 assembly.setFormats( formats );
831                 while ( parser.nextTag() == XmlPullParser.START_TAG )
832                 {
833                     if ( "format".equals( parser.getName() ) )
834                     {
835                         formats.add( getTrimmedValue( parser.nextText() ) );
836                     }
837                     else
838                     {
839                         checkUnknownElement( parser, strict );
840                     }
841                 }
842             }
843             else if ( checkFieldWithDuplicate( parser, "includeBaseDirectory", null, parsed ) )
844             {
845                 assembly.setIncludeBaseDirectory( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeBaseDirectory", parser, "true" ) );
846             }
847             else if ( checkFieldWithDuplicate( parser, "baseDirectory", null, parsed ) )
848             {
849                 assembly.setBaseDirectory( getTrimmedValue( parser.nextText() ) );
850             }
851             else if ( checkFieldWithDuplicate( parser, "includeSiteDirectory", null, parsed ) )
852             {
853                 assembly.setIncludeSiteDirectory( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeSiteDirectory", parser, "false" ) );
854             }
855             else if ( checkFieldWithDuplicate( parser, "containerDescriptorHandlers", null, parsed ) )
856             {
857                 java.util.List containerDescriptorHandlers = new java.util.ArrayList/*<ContainerDescriptorHandlerConfig>*/();
858                 assembly.setContainerDescriptorHandlers( containerDescriptorHandlers );
859                 while ( parser.nextTag() == XmlPullParser.START_TAG )
860                 {
861                     if ( "containerDescriptorHandler".equals( parser.getName() ) )
862                     {
863                         containerDescriptorHandlers.add( parseContainerDescriptorHandlerConfig( parser, strict ) );
864                     }
865                     else
866                     {
867                         checkUnknownElement( parser, strict );
868                     }
869                 }
870             }
871             else if ( checkFieldWithDuplicate( parser, "moduleSets", null, parsed ) )
872             {
873                 java.util.List moduleSets = new java.util.ArrayList/*<ModuleSet>*/();
874                 assembly.setModuleSets( moduleSets );
875                 while ( parser.nextTag() == XmlPullParser.START_TAG )
876                 {
877                     if ( "moduleSet".equals( parser.getName() ) )
878                     {
879                         moduleSets.add( parseModuleSet( parser, strict ) );
880                     }
881                     else
882                     {
883                         checkUnknownElement( parser, strict );
884                     }
885                 }
886             }
887             else if ( checkFieldWithDuplicate( parser, "fileSets", null, parsed ) )
888             {
889                 java.util.List fileSets = new java.util.ArrayList/*<FileSet>*/();
890                 assembly.setFileSets( fileSets );
891                 while ( parser.nextTag() == XmlPullParser.START_TAG )
892                 {
893                     if ( "fileSet".equals( parser.getName() ) )
894                     {
895                         fileSets.add( parseFileSet( parser, strict ) );
896                     }
897                     else
898                     {
899                         checkUnknownElement( parser, strict );
900                     }
901                 }
902             }
903             else if ( checkFieldWithDuplicate( parser, "files", null, parsed ) )
904             {
905                 java.util.List files = new java.util.ArrayList/*<FileItem>*/();
906                 assembly.setFiles( files );
907                 while ( parser.nextTag() == XmlPullParser.START_TAG )
908                 {
909                     if ( "file".equals( parser.getName() ) )
910                     {
911                         files.add( parseFileItem( parser, strict ) );
912                     }
913                     else
914                     {
915                         checkUnknownElement( parser, strict );
916                     }
917                 }
918             }
919             else if ( checkFieldWithDuplicate( parser, "dependencySets", null, parsed ) )
920             {
921                 java.util.List dependencySets = new java.util.ArrayList/*<DependencySet>*/();
922                 assembly.setDependencySets( dependencySets );
923                 while ( parser.nextTag() == XmlPullParser.START_TAG )
924                 {
925                     if ( "dependencySet".equals( parser.getName() ) )
926                     {
927                         dependencySets.add( parseDependencySet( parser, strict ) );
928                     }
929                     else
930                     {
931                         checkUnknownElement( parser, strict );
932                     }
933                 }
934             }
935             else if ( checkFieldWithDuplicate( parser, "repositories", null, parsed ) )
936             {
937                 java.util.List repositories = new java.util.ArrayList/*<Repository>*/();
938                 assembly.setRepositories( repositories );
939                 while ( parser.nextTag() == XmlPullParser.START_TAG )
940                 {
941                     if ( "repository".equals( parser.getName() ) )
942                     {
943                         repositories.add( parseRepository( parser, strict ) );
944                     }
945                     else
946                     {
947                         checkUnknownElement( parser, strict );
948                     }
949                 }
950             }
951             else if ( checkFieldWithDuplicate( parser, "componentDescriptors", null, parsed ) )
952             {
953                 java.util.List componentDescriptors = new java.util.ArrayList/*<String>*/();
954                 assembly.setComponentDescriptors( componentDescriptors );
955                 while ( parser.nextTag() == XmlPullParser.START_TAG )
956                 {
957                     if ( "componentDescriptor".equals( parser.getName() ) )
958                     {
959                         componentDescriptors.add( getTrimmedValue( parser.nextText() ) );
960                     }
961                     else
962                     {
963                         checkUnknownElement( parser, strict );
964                     }
965                 }
966             }
967             else
968             {
969                 checkUnknownElement( parser, strict );
970             }
971         }
972         return assembly;
973     } //-- Assembly parseAssembly( XmlPullParser, boolean )
974 
975     /**
976      * Method parseContainerDescriptorHandlerConfig.
977      * 
978      * @param parser
979      * @param strict
980      * @throws IOException
981      * @throws XmlPullParserException
982      * @return ContainerDescriptorHandlerConfig
983      */
984     private ContainerDescriptorHandlerConfig parseContainerDescriptorHandlerConfig( XmlPullParser parser, boolean strict )
985         throws IOException, XmlPullParserException
986     {
987         String tagName = parser.getName();
988         ContainerDescriptorHandlerConfig containerDescriptorHandlerConfig = new ContainerDescriptorHandlerConfig();
989         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
990         {
991             String name = parser.getAttributeName( i );
992             String value = parser.getAttributeValue( i );
993 
994             if ( name.indexOf( ':' ) >= 0 )
995             {
996                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
997             }
998             else
999             {
1000                 checkUnknownAttribute( parser, name, tagName, strict );
1001             }
1002         }
1003         java.util.Set parsed = new java.util.HashSet();
1004         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1005         {
1006             if ( checkFieldWithDuplicate( parser, "handlerName", null, parsed ) )
1007             {
1008                 containerDescriptorHandlerConfig.setHandlerName( getTrimmedValue( parser.nextText() ) );
1009             }
1010             else if ( checkFieldWithDuplicate( parser, "configuration", null, parsed ) )
1011             {
1012                 containerDescriptorHandlerConfig.setConfiguration( Xpp3DomBuilder.build( parser ) );
1013             }
1014             else
1015             {
1016                 checkUnknownElement( parser, strict );
1017             }
1018         }
1019         return containerDescriptorHandlerConfig;
1020     } //-- ContainerDescriptorHandlerConfig parseContainerDescriptorHandlerConfig( XmlPullParser, boolean )
1021 
1022     /**
1023      * Method parseDependencySet.
1024      * 
1025      * @param parser
1026      * @param strict
1027      * @throws IOException
1028      * @throws XmlPullParserException
1029      * @return DependencySet
1030      */
1031     private DependencySet parseDependencySet( XmlPullParser parser, boolean strict )
1032         throws IOException, XmlPullParserException
1033     {
1034         String tagName = parser.getName();
1035         DependencySet dependencySet = new DependencySet();
1036         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1037         {
1038             String name = parser.getAttributeName( i );
1039             String value = parser.getAttributeValue( i );
1040 
1041             if ( name.indexOf( ':' ) >= 0 )
1042             {
1043                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1044             }
1045             else
1046             {
1047                 checkUnknownAttribute( parser, name, tagName, strict );
1048             }
1049         }
1050         java.util.Set parsed = new java.util.HashSet();
1051         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1052         {
1053             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1054             {
1055                 dependencySet.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1056             }
1057             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1058             {
1059                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1060                 dependencySet.setIncludes( includes );
1061                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1062                 {
1063                     if ( "include".equals( parser.getName() ) )
1064                     {
1065                         includes.add( getTrimmedValue( parser.nextText() ) );
1066                     }
1067                     else
1068                     {
1069                         checkUnknownElement( parser, strict );
1070                     }
1071                 }
1072             }
1073             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1074             {
1075                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1076                 dependencySet.setExcludes( excludes );
1077                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1078                 {
1079                     if ( "exclude".equals( parser.getName() ) )
1080                     {
1081                         excludes.add( getTrimmedValue( parser.nextText() ) );
1082                     }
1083                     else
1084                     {
1085                         checkUnknownElement( parser, strict );
1086                     }
1087                 }
1088             }
1089             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1090             {
1091                 dependencySet.setFileMode( getTrimmedValue( parser.nextText() ) );
1092             }
1093             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1094             {
1095                 dependencySet.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1096             }
1097             else if ( checkFieldWithDuplicate( parser, "useStrictFiltering", null, parsed ) )
1098             {
1099                 dependencySet.setUseStrictFiltering( getBooleanValue( getTrimmedValue( parser.nextText() ), "useStrictFiltering", parser, "false" ) );
1100             }
1101             else if ( checkFieldWithDuplicate( parser, "outputFileNameMapping", null, parsed ) )
1102             {
1103                 dependencySet.setOutputFileNameMapping( getTrimmedValue( parser.nextText() ) );
1104             }
1105             else if ( checkFieldWithDuplicate( parser, "unpack", null, parsed ) )
1106             {
1107                 dependencySet.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText() ), "unpack", parser, "false" ) );
1108             }
1109             else if ( checkFieldWithDuplicate( parser, "unpackOptions", null, parsed ) )
1110             {
1111                 dependencySet.setUnpackOptions( parseUnpackOptions( parser, strict ) );
1112             }
1113             else if ( checkFieldWithDuplicate( parser, "scope", null, parsed ) )
1114             {
1115                 dependencySet.setScope( getTrimmedValue( parser.nextText() ) );
1116             }
1117             else if ( checkFieldWithDuplicate( parser, "useProjectArtifact", null, parsed ) )
1118             {
1119                 dependencySet.setUseProjectArtifact( getBooleanValue( getTrimmedValue( parser.nextText() ), "useProjectArtifact", parser, "true" ) );
1120             }
1121             else if ( checkFieldWithDuplicate( parser, "useProjectAttachments", null, parsed ) )
1122             {
1123                 dependencySet.setUseProjectAttachments( getBooleanValue( getTrimmedValue( parser.nextText() ), "useProjectAttachments", parser, "false" ) );
1124             }
1125             else if ( checkFieldWithDuplicate( parser, "useTransitiveDependencies", null, parsed ) )
1126             {
1127                 dependencySet.setUseTransitiveDependencies( getBooleanValue( getTrimmedValue( parser.nextText() ), "useTransitiveDependencies", parser, "true" ) );
1128             }
1129             else if ( checkFieldWithDuplicate( parser, "useTransitiveFiltering", null, parsed ) )
1130             {
1131                 dependencySet.setUseTransitiveFiltering( getBooleanValue( getTrimmedValue( parser.nextText() ), "useTransitiveFiltering", parser, "false" ) );
1132             }
1133             else
1134             {
1135                 checkUnknownElement( parser, strict );
1136             }
1137         }
1138         return dependencySet;
1139     } //-- DependencySet parseDependencySet( XmlPullParser, boolean )
1140 
1141     /**
1142      * Method parseFileItem.
1143      * 
1144      * @param parser
1145      * @param strict
1146      * @throws IOException
1147      * @throws XmlPullParserException
1148      * @return FileItem
1149      */
1150     private FileItem parseFileItem( XmlPullParser parser, boolean strict )
1151         throws IOException, XmlPullParserException
1152     {
1153         String tagName = parser.getName();
1154         FileItem fileItem = new FileItem();
1155         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1156         {
1157             String name = parser.getAttributeName( i );
1158             String value = parser.getAttributeValue( i );
1159 
1160             if ( name.indexOf( ':' ) >= 0 )
1161             {
1162                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1163             }
1164             else
1165             {
1166                 checkUnknownAttribute( parser, name, tagName, strict );
1167             }
1168         }
1169         java.util.Set parsed = new java.util.HashSet();
1170         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1171         {
1172             if ( checkFieldWithDuplicate( parser, "source", null, parsed ) )
1173             {
1174                 fileItem.setSource( getTrimmedValue( parser.nextText() ) );
1175             }
1176             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1177             {
1178                 fileItem.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1179             }
1180             else if ( checkFieldWithDuplicate( parser, "destName", null, parsed ) )
1181             {
1182                 fileItem.setDestName( getTrimmedValue( parser.nextText() ) );
1183             }
1184             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1185             {
1186                 fileItem.setFileMode( getTrimmedValue( parser.nextText() ) );
1187             }
1188             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1189             {
1190                 fileItem.setLineEnding( getTrimmedValue( parser.nextText() ) );
1191             }
1192             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1193             {
1194                 fileItem.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1195             }
1196             else
1197             {
1198                 checkUnknownElement( parser, strict );
1199             }
1200         }
1201         return fileItem;
1202     } //-- FileItem parseFileItem( XmlPullParser, boolean )
1203 
1204     /**
1205      * Method parseFileSet.
1206      * 
1207      * @param parser
1208      * @param strict
1209      * @throws IOException
1210      * @throws XmlPullParserException
1211      * @return FileSet
1212      */
1213     private FileSet parseFileSet( XmlPullParser parser, boolean strict )
1214         throws IOException, XmlPullParserException
1215     {
1216         String tagName = parser.getName();
1217         FileSet fileSet = new FileSet();
1218         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1219         {
1220             String name = parser.getAttributeName( i );
1221             String value = parser.getAttributeValue( i );
1222 
1223             if ( name.indexOf( ':' ) >= 0 )
1224             {
1225                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1226             }
1227             else
1228             {
1229                 checkUnknownAttribute( parser, name, tagName, strict );
1230             }
1231         }
1232         java.util.Set parsed = new java.util.HashSet();
1233         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1234         {
1235             if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1236             {
1237                 fileSet.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1238             }
1239             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1240             {
1241                 fileSet.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1242             }
1243             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1244             {
1245                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1246                 fileSet.setIncludes( includes );
1247                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1248                 {
1249                     if ( "include".equals( parser.getName() ) )
1250                     {
1251                         includes.add( getTrimmedValue( parser.nextText() ) );
1252                     }
1253                     else
1254                     {
1255                         checkUnknownElement( parser, strict );
1256                     }
1257                 }
1258             }
1259             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1260             {
1261                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1262                 fileSet.setExcludes( excludes );
1263                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1264                 {
1265                     if ( "exclude".equals( parser.getName() ) )
1266                     {
1267                         excludes.add( getTrimmedValue( parser.nextText() ) );
1268                     }
1269                     else
1270                     {
1271                         checkUnknownElement( parser, strict );
1272                     }
1273                 }
1274             }
1275             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1276             {
1277                 fileSet.setFileMode( getTrimmedValue( parser.nextText() ) );
1278             }
1279             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1280             {
1281                 fileSet.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1282             }
1283             else if ( checkFieldWithDuplicate( parser, "directory", null, parsed ) )
1284             {
1285                 fileSet.setDirectory( getTrimmedValue( parser.nextText() ) );
1286             }
1287             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1288             {
1289                 fileSet.setLineEnding( getTrimmedValue( parser.nextText() ) );
1290             }
1291             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1292             {
1293                 fileSet.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1294             }
1295             else
1296             {
1297                 checkUnknownElement( parser, strict );
1298             }
1299         }
1300         return fileSet;
1301     } //-- FileSet parseFileSet( XmlPullParser, boolean )
1302 
1303     /**
1304      * Method parseGroupVersionAlignment.
1305      * 
1306      * @param parser
1307      * @param strict
1308      * @throws IOException
1309      * @throws XmlPullParserException
1310      * @return GroupVersionAlignment
1311      */
1312     private GroupVersionAlignment parseGroupVersionAlignment( XmlPullParser parser, boolean strict )
1313         throws IOException, XmlPullParserException
1314     {
1315         String tagName = parser.getName();
1316         GroupVersionAlignment groupVersionAlignment = new GroupVersionAlignment();
1317         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1318         {
1319             String name = parser.getAttributeName( i );
1320             String value = parser.getAttributeValue( i );
1321 
1322             if ( name.indexOf( ':' ) >= 0 )
1323             {
1324                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1325             }
1326             else
1327             {
1328                 checkUnknownAttribute( parser, name, tagName, strict );
1329             }
1330         }
1331         java.util.Set parsed = new java.util.HashSet();
1332         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1333         {
1334             if ( checkFieldWithDuplicate( parser, "id", null, parsed ) )
1335             {
1336                 groupVersionAlignment.setId( getTrimmedValue( parser.nextText() ) );
1337             }
1338             else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
1339             {
1340                 groupVersionAlignment.setVersion( getTrimmedValue( parser.nextText() ) );
1341             }
1342             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1343             {
1344                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1345                 groupVersionAlignment.setExcludes( excludes );
1346                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1347                 {
1348                     if ( "exclude".equals( parser.getName() ) )
1349                     {
1350                         excludes.add( getTrimmedValue( parser.nextText() ) );
1351                     }
1352                     else
1353                     {
1354                         checkUnknownElement( parser, strict );
1355                     }
1356                 }
1357             }
1358             else
1359             {
1360                 checkUnknownElement( parser, strict );
1361             }
1362         }
1363         return groupVersionAlignment;
1364     } //-- GroupVersionAlignment parseGroupVersionAlignment( XmlPullParser, boolean )
1365 
1366     /**
1367      * Method parseModuleBinaries.
1368      * 
1369      * @param parser
1370      * @param strict
1371      * @throws IOException
1372      * @throws XmlPullParserException
1373      * @return ModuleBinaries
1374      */
1375     private ModuleBinaries parseModuleBinaries( XmlPullParser parser, boolean strict )
1376         throws IOException, XmlPullParserException
1377     {
1378         String tagName = parser.getName();
1379         ModuleBinaries moduleBinaries = new ModuleBinaries();
1380         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1381         {
1382             String name = parser.getAttributeName( i );
1383             String value = parser.getAttributeValue( i );
1384 
1385             if ( name.indexOf( ':' ) >= 0 )
1386             {
1387                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1388             }
1389             else
1390             {
1391                 checkUnknownAttribute( parser, name, tagName, strict );
1392             }
1393         }
1394         java.util.Set parsed = new java.util.HashSet();
1395         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1396         {
1397             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1398             {
1399                 moduleBinaries.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1400             }
1401             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1402             {
1403                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1404                 moduleBinaries.setIncludes( includes );
1405                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1406                 {
1407                     if ( "include".equals( parser.getName() ) )
1408                     {
1409                         includes.add( getTrimmedValue( parser.nextText() ) );
1410                     }
1411                     else
1412                     {
1413                         checkUnknownElement( parser, strict );
1414                     }
1415                 }
1416             }
1417             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1418             {
1419                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1420                 moduleBinaries.setExcludes( excludes );
1421                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1422                 {
1423                     if ( "exclude".equals( parser.getName() ) )
1424                     {
1425                         excludes.add( getTrimmedValue( parser.nextText() ) );
1426                     }
1427                     else
1428                     {
1429                         checkUnknownElement( parser, strict );
1430                     }
1431                 }
1432             }
1433             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1434             {
1435                 moduleBinaries.setFileMode( getTrimmedValue( parser.nextText() ) );
1436             }
1437             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1438             {
1439                 moduleBinaries.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1440             }
1441             else if ( checkFieldWithDuplicate( parser, "attachmentClassifier", null, parsed ) )
1442             {
1443                 moduleBinaries.setAttachmentClassifier( getTrimmedValue( parser.nextText() ) );
1444             }
1445             else if ( checkFieldWithDuplicate( parser, "includeDependencies", null, parsed ) )
1446             {
1447                 moduleBinaries.setIncludeDependencies( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeDependencies", parser, "true" ) );
1448             }
1449             else if ( checkFieldWithDuplicate( parser, "dependencySets", null, parsed ) )
1450             {
1451                 java.util.List dependencySets = new java.util.ArrayList/*<DependencySet>*/();
1452                 moduleBinaries.setDependencySets( dependencySets );
1453                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1454                 {
1455                     if ( "dependencySet".equals( parser.getName() ) )
1456                     {
1457                         dependencySets.add( parseDependencySet( parser, strict ) );
1458                     }
1459                     else
1460                     {
1461                         checkUnknownElement( parser, strict );
1462                     }
1463                 }
1464             }
1465             else if ( checkFieldWithDuplicate( parser, "unpack", null, parsed ) )
1466             {
1467                 moduleBinaries.setUnpack( getBooleanValue( getTrimmedValue( parser.nextText() ), "unpack", parser, "true" ) );
1468             }
1469             else if ( checkFieldWithDuplicate( parser, "unpackOptions", null, parsed ) )
1470             {
1471                 moduleBinaries.setUnpackOptions( parseUnpackOptions( parser, strict ) );
1472             }
1473             else if ( checkFieldWithDuplicate( parser, "outputFileNameMapping", null, parsed ) )
1474             {
1475                 moduleBinaries.setOutputFileNameMapping( getTrimmedValue( parser.nextText() ) );
1476             }
1477             else
1478             {
1479                 checkUnknownElement( parser, strict );
1480             }
1481         }
1482         return moduleBinaries;
1483     } //-- ModuleBinaries parseModuleBinaries( XmlPullParser, boolean )
1484 
1485     /**
1486      * Method parseModuleSet.
1487      * 
1488      * @param parser
1489      * @param strict
1490      * @throws IOException
1491      * @throws XmlPullParserException
1492      * @return ModuleSet
1493      */
1494     private ModuleSet parseModuleSet( XmlPullParser parser, boolean strict )
1495         throws IOException, XmlPullParserException
1496     {
1497         String tagName = parser.getName();
1498         ModuleSet moduleSet = new ModuleSet();
1499         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1500         {
1501             String name = parser.getAttributeName( i );
1502             String value = parser.getAttributeValue( i );
1503 
1504             if ( name.indexOf( ':' ) >= 0 )
1505             {
1506                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1507             }
1508             else
1509             {
1510                 checkUnknownAttribute( parser, name, tagName, strict );
1511             }
1512         }
1513         java.util.Set parsed = new java.util.HashSet();
1514         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1515         {
1516             if ( checkFieldWithDuplicate( parser, "useAllReactorProjects", null, parsed ) )
1517             {
1518                 moduleSet.setUseAllReactorProjects( getBooleanValue( getTrimmedValue( parser.nextText() ), "useAllReactorProjects", parser, "false" ) );
1519             }
1520             else if ( checkFieldWithDuplicate( parser, "includeSubModules", null, parsed ) )
1521             {
1522                 moduleSet.setIncludeSubModules( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeSubModules", parser, "true" ) );
1523             }
1524             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1525             {
1526                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1527                 moduleSet.setIncludes( includes );
1528                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1529                 {
1530                     if ( "include".equals( parser.getName() ) )
1531                     {
1532                         includes.add( getTrimmedValue( parser.nextText() ) );
1533                     }
1534                     else
1535                     {
1536                         checkUnknownElement( parser, strict );
1537                     }
1538                 }
1539             }
1540             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1541             {
1542                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1543                 moduleSet.setExcludes( excludes );
1544                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1545                 {
1546                     if ( "exclude".equals( parser.getName() ) )
1547                     {
1548                         excludes.add( getTrimmedValue( parser.nextText() ) );
1549                     }
1550                     else
1551                     {
1552                         checkUnknownElement( parser, strict );
1553                     }
1554                 }
1555             }
1556             else if ( checkFieldWithDuplicate( parser, "sources", null, parsed ) )
1557             {
1558                 moduleSet.setSources( parseModuleSources( parser, strict ) );
1559             }
1560             else if ( checkFieldWithDuplicate( parser, "binaries", null, parsed ) )
1561             {
1562                 moduleSet.setBinaries( parseModuleBinaries( parser, strict ) );
1563             }
1564             else
1565             {
1566                 checkUnknownElement( parser, strict );
1567             }
1568         }
1569         return moduleSet;
1570     } //-- ModuleSet parseModuleSet( XmlPullParser, boolean )
1571 
1572     /**
1573      * Method parseModuleSources.
1574      * 
1575      * @param parser
1576      * @param strict
1577      * @throws IOException
1578      * @throws XmlPullParserException
1579      * @return ModuleSources
1580      */
1581     private ModuleSources parseModuleSources( XmlPullParser parser, boolean strict )
1582         throws IOException, XmlPullParserException
1583     {
1584         String tagName = parser.getName();
1585         ModuleSources moduleSources = new ModuleSources();
1586         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1587         {
1588             String name = parser.getAttributeName( i );
1589             String value = parser.getAttributeValue( i );
1590 
1591             if ( name.indexOf( ':' ) >= 0 )
1592             {
1593                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1594             }
1595             else
1596             {
1597                 checkUnknownAttribute( parser, name, tagName, strict );
1598             }
1599         }
1600         java.util.Set parsed = new java.util.HashSet();
1601         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1602         {
1603             if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1604             {
1605                 moduleSources.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1606             }
1607             else if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1608             {
1609                 moduleSources.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1610             }
1611             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1612             {
1613                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1614                 moduleSources.setIncludes( includes );
1615                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1616                 {
1617                     if ( "include".equals( parser.getName() ) )
1618                     {
1619                         includes.add( getTrimmedValue( parser.nextText() ) );
1620                     }
1621                     else
1622                     {
1623                         checkUnknownElement( parser, strict );
1624                     }
1625                 }
1626             }
1627             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1628             {
1629                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1630                 moduleSources.setExcludes( excludes );
1631                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1632                 {
1633                     if ( "exclude".equals( parser.getName() ) )
1634                     {
1635                         excludes.add( getTrimmedValue( parser.nextText() ) );
1636                     }
1637                     else
1638                     {
1639                         checkUnknownElement( parser, strict );
1640                     }
1641                 }
1642             }
1643             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1644             {
1645                 moduleSources.setFileMode( getTrimmedValue( parser.nextText() ) );
1646             }
1647             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1648             {
1649                 moduleSources.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1650             }
1651             else if ( checkFieldWithDuplicate( parser, "fileSets", null, parsed ) )
1652             {
1653                 java.util.List fileSets = new java.util.ArrayList/*<FileSet>*/();
1654                 moduleSources.setFileSets( fileSets );
1655                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1656                 {
1657                     if ( "fileSet".equals( parser.getName() ) )
1658                     {
1659                         fileSets.add( parseFileSet( parser, strict ) );
1660                     }
1661                     else
1662                     {
1663                         checkUnknownElement( parser, strict );
1664                     }
1665                 }
1666             }
1667             else if ( checkFieldWithDuplicate( parser, "includeModuleDirectory", null, parsed ) )
1668             {
1669                 moduleSources.setIncludeModuleDirectory( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeModuleDirectory", parser, "true" ) );
1670             }
1671             else if ( checkFieldWithDuplicate( parser, "excludeSubModuleDirectories", null, parsed ) )
1672             {
1673                 moduleSources.setExcludeSubModuleDirectories( getBooleanValue( getTrimmedValue( parser.nextText() ), "excludeSubModuleDirectories", parser, "true" ) );
1674             }
1675             else if ( checkFieldWithDuplicate( parser, "outputDirectoryMapping", null, parsed ) )
1676             {
1677                 moduleSources.setOutputDirectoryMapping( getTrimmedValue( parser.nextText() ) );
1678             }
1679             else
1680             {
1681                 checkUnknownElement( parser, strict );
1682             }
1683         }
1684         return moduleSources;
1685     } //-- ModuleSources parseModuleSources( XmlPullParser, boolean )
1686 
1687     /**
1688      * Method parseRepository.
1689      * 
1690      * @param parser
1691      * @param strict
1692      * @throws IOException
1693      * @throws XmlPullParserException
1694      * @return Repository
1695      */
1696     private Repository parseRepository( XmlPullParser parser, boolean strict )
1697         throws IOException, XmlPullParserException
1698     {
1699         String tagName = parser.getName();
1700         Repository repository = new Repository();
1701         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1702         {
1703             String name = parser.getAttributeName( i );
1704             String value = parser.getAttributeValue( i );
1705 
1706             if ( name.indexOf( ':' ) >= 0 )
1707             {
1708                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1709             }
1710             else
1711             {
1712                 checkUnknownAttribute( parser, name, tagName, strict );
1713             }
1714         }
1715         java.util.Set parsed = new java.util.HashSet();
1716         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1717         {
1718             if ( checkFieldWithDuplicate( parser, "outputDirectory", null, parsed ) )
1719             {
1720                 repository.setOutputDirectory( getTrimmedValue( parser.nextText() ) );
1721             }
1722             else if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1723             {
1724                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1725                 repository.setIncludes( includes );
1726                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1727                 {
1728                     if ( "include".equals( parser.getName() ) )
1729                     {
1730                         includes.add( getTrimmedValue( parser.nextText() ) );
1731                     }
1732                     else
1733                     {
1734                         checkUnknownElement( parser, strict );
1735                     }
1736                 }
1737             }
1738             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1739             {
1740                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1741                 repository.setExcludes( excludes );
1742                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1743                 {
1744                     if ( "exclude".equals( parser.getName() ) )
1745                     {
1746                         excludes.add( getTrimmedValue( parser.nextText() ) );
1747                     }
1748                     else
1749                     {
1750                         checkUnknownElement( parser, strict );
1751                     }
1752                 }
1753             }
1754             else if ( checkFieldWithDuplicate( parser, "fileMode", null, parsed ) )
1755             {
1756                 repository.setFileMode( getTrimmedValue( parser.nextText() ) );
1757             }
1758             else if ( checkFieldWithDuplicate( parser, "directoryMode", null, parsed ) )
1759             {
1760                 repository.setDirectoryMode( getTrimmedValue( parser.nextText() ) );
1761             }
1762             else if ( checkFieldWithDuplicate( parser, "includeMetadata", null, parsed ) )
1763             {
1764                 repository.setIncludeMetadata( getBooleanValue( getTrimmedValue( parser.nextText() ), "includeMetadata", parser, "false" ) );
1765             }
1766             else if ( checkFieldWithDuplicate( parser, "groupVersionAlignments", null, parsed ) )
1767             {
1768                 java.util.List groupVersionAlignments = new java.util.ArrayList/*<GroupVersionAlignment>*/();
1769                 repository.setGroupVersionAlignments( groupVersionAlignments );
1770                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1771                 {
1772                     if ( "groupVersionAlignment".equals( parser.getName() ) )
1773                     {
1774                         groupVersionAlignments.add( parseGroupVersionAlignment( parser, strict ) );
1775                     }
1776                     else
1777                     {
1778                         checkUnknownElement( parser, strict );
1779                     }
1780                 }
1781             }
1782             else if ( checkFieldWithDuplicate( parser, "scope", null, parsed ) )
1783             {
1784                 repository.setScope( getTrimmedValue( parser.nextText() ) );
1785             }
1786             else
1787             {
1788                 checkUnknownElement( parser, strict );
1789             }
1790         }
1791         return repository;
1792     } //-- Repository parseRepository( XmlPullParser, boolean )
1793 
1794     /**
1795      * Method parseUnpackOptions.
1796      * 
1797      * @param parser
1798      * @param strict
1799      * @throws IOException
1800      * @throws XmlPullParserException
1801      * @return UnpackOptions
1802      */
1803     private UnpackOptions parseUnpackOptions( XmlPullParser parser, boolean strict )
1804         throws IOException, XmlPullParserException
1805     {
1806         String tagName = parser.getName();
1807         UnpackOptions unpackOptions = new UnpackOptions();
1808         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1809         {
1810             String name = parser.getAttributeName( i );
1811             String value = parser.getAttributeValue( i );
1812 
1813             if ( name.indexOf( ':' ) >= 0 )
1814             {
1815                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
1816             }
1817             else
1818             {
1819                 checkUnknownAttribute( parser, name, tagName, strict );
1820             }
1821         }
1822         java.util.Set parsed = new java.util.HashSet();
1823         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1824         {
1825             if ( checkFieldWithDuplicate( parser, "includes", null, parsed ) )
1826             {
1827                 java.util.List includes = new java.util.ArrayList/*<String>*/();
1828                 unpackOptions.setIncludes( includes );
1829                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1830                 {
1831                     if ( "include".equals( parser.getName() ) )
1832                     {
1833                         includes.add( getTrimmedValue( parser.nextText() ) );
1834                     }
1835                     else
1836                     {
1837                         checkUnknownElement( parser, strict );
1838                     }
1839                 }
1840             }
1841             else if ( checkFieldWithDuplicate( parser, "excludes", null, parsed ) )
1842             {
1843                 java.util.List excludes = new java.util.ArrayList/*<String>*/();
1844                 unpackOptions.setExcludes( excludes );
1845                 while ( parser.nextTag() == XmlPullParser.START_TAG )
1846                 {
1847                     if ( "exclude".equals( parser.getName() ) )
1848                     {
1849                         excludes.add( getTrimmedValue( parser.nextText() ) );
1850                     }
1851                     else
1852                     {
1853                         checkUnknownElement( parser, strict );
1854                     }
1855                 }
1856             }
1857             else if ( checkFieldWithDuplicate( parser, "filtered", null, parsed ) )
1858             {
1859                 unpackOptions.setFiltered( getBooleanValue( getTrimmedValue( parser.nextText() ), "filtered", parser, "false" ) );
1860             }
1861             else if ( checkFieldWithDuplicate( parser, "lineEnding", null, parsed ) )
1862             {
1863                 unpackOptions.setLineEnding( getTrimmedValue( parser.nextText() ) );
1864             }
1865             else if ( checkFieldWithDuplicate( parser, "useDefaultExcludes", null, parsed ) )
1866             {
1867                 unpackOptions.setUseDefaultExcludes( getBooleanValue( getTrimmedValue( parser.nextText() ), "useDefaultExcludes", parser, "true" ) );
1868             }
1869             else
1870             {
1871                 checkUnknownElement( parser, strict );
1872             }
1873         }
1874         return unpackOptions;
1875     } //-- UnpackOptions parseUnpackOptions( XmlPullParser, boolean )
1876 
1877     /**
1878      * @see ReaderFactory#newXmlReader
1879      * 
1880      * @param reader
1881      * @param strict
1882      * @throws IOException
1883      * @throws XmlPullParserException
1884      * @return Assembly
1885      */
1886     public Assembly read( Reader reader, boolean strict )
1887         throws IOException, XmlPullParserException
1888     {
1889         XmlPullParser parser = new MXParser();
1890 
1891         parser.setInput( reader );
1892 
1893         initParser( parser );
1894 
1895         return read( parser, strict );
1896     } //-- Assembly read( Reader, boolean )
1897 
1898     /**
1899      * @see ReaderFactory#newXmlReader
1900      * 
1901      * @param reader
1902      * @throws IOException
1903      * @throws XmlPullParserException
1904      * @return Assembly
1905      */
1906     public Assembly read( Reader reader )
1907         throws IOException, XmlPullParserException
1908     {
1909         return read( reader, true );
1910     } //-- Assembly read( Reader )
1911 
1912     /**
1913      * Method read.
1914      * 
1915      * @param in
1916      * @param strict
1917      * @throws IOException
1918      * @throws XmlPullParserException
1919      * @return Assembly
1920      */
1921     public Assembly read( InputStream in, boolean strict )
1922         throws IOException, XmlPullParserException
1923     {
1924         return read( ReaderFactory.newXmlReader( in ), strict );
1925     } //-- Assembly read( InputStream, boolean )
1926 
1927     /**
1928      * Method read.
1929      * 
1930      * @param in
1931      * @throws IOException
1932      * @throws XmlPullParserException
1933      * @return Assembly
1934      */
1935     public Assembly read( InputStream in )
1936         throws IOException, XmlPullParserException
1937     {
1938         return read( ReaderFactory.newXmlReader( in ) );
1939     } //-- Assembly read( InputStream )
1940 
1941     /**
1942      * Method read.
1943      * 
1944      * @param parser
1945      * @param strict
1946      * @throws IOException
1947      * @throws XmlPullParserException
1948      * @return Assembly
1949      */
1950     private Assembly read( XmlPullParser parser, boolean strict )
1951         throws IOException, XmlPullParserException
1952     {
1953         int eventType = parser.getEventType();
1954         while ( eventType != XmlPullParser.END_DOCUMENT )
1955         {
1956             if ( eventType == XmlPullParser.START_TAG )
1957             {
1958                 if ( strict && ! "assembly".equals( parser.getName() ) )
1959                 {
1960                     throw new XmlPullParserException( "Expected root element 'assembly' but found '" + parser.getName() + "'", parser, null );
1961                 }
1962                 Assembly assembly = parseAssembly( parser, strict );
1963                 assembly.setModelEncoding( parser.getInputEncoding() );
1964                 return assembly;
1965             }
1966             eventType = parser.next();
1967         }
1968         throw new XmlPullParserException( "Expected root element 'assembly' but found no element at all: invalid XML document", parser, null );
1969     } //-- Assembly read( XmlPullParser, boolean )
1970 
1971     /**
1972      * Sets the state of the "add default entities" flag.
1973      * 
1974      * @param addDefaultEntities
1975      */
1976     public void setAddDefaultEntities( boolean addDefaultEntities )
1977     {
1978         this.addDefaultEntities = addDefaultEntities;
1979     } //-- void setAddDefaultEntities( boolean )
1980 
1981 }