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