View Javadoc
1   // =================== DO NOT EDIT THIS FILE ====================
2   // Generated by Modello 1.8.3,
3   // any modifications will be overwritten.
4   // ==============================================================
5   
6   package org.apache.maven.plugin.lifecycle.io.xpp3;
7   
8     //---------------------------------/
9    //- Imported classes and packages -/
10  //---------------------------------/
11  
12  import java.io.IOException;
13  import java.io.InputStream;
14  import java.io.Reader;
15  import java.text.DateFormat;
16  import org.apache.maven.plugin.lifecycle.Execution;
17  import org.apache.maven.plugin.lifecycle.Lifecycle;
18  import org.apache.maven.plugin.lifecycle.LifecycleConfiguration;
19  import org.apache.maven.plugin.lifecycle.Phase;
20  import org.codehaus.plexus.util.ReaderFactory;
21  import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
22  import org.codehaus.plexus.util.xml.pull.MXParser;
23  import org.codehaus.plexus.util.xml.pull.XmlPullParser;
24  import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
25  
26  /**
27   * Class LifecycleMappingsXpp3Reader.
28   * 
29   * @version $Revision: 965443 $ $Date: 2015-09-14 15:18:52 -0700 (Mon, 14 Sep 2015) $
30   */
31  @SuppressWarnings( "all" )
32  public class LifecycleMappingsXpp3Reader
33  {
34  
35        //--------------------------/
36       //- Class/Member Variables -/
37      //--------------------------/
38  
39      /**
40       * If set the parser will be loaded with all single characters
41       * from the XHTML specification.
42       * The entities used:
43       * <ul>
44       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>;
45       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>;
46       * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>;
47       * </ul>
48       */
49      private boolean addDefaultEntities = true;
50  
51      /**
52       * Field contentTransformer.
53       */
54      public final ContentTransformer contentTransformer;
55  
56  
57        //----------------/
58       //- Constructors -/
59      //----------------/
60  
61      public LifecycleMappingsXpp3Reader()
62      {
63          this( new ContentTransformer()
64          {
65              public String transform( String source, String fieldName )
66              {
67                  return source;
68              }
69          } );
70      } //-- org.apache.maven.plugin.lifecycle.io.xpp3.LifecycleMappingsXpp3Reader()
71  
72      public LifecycleMappingsXpp3Reader(ContentTransformer contentTransformer)
73      {
74          this.contentTransformer = contentTransformer;
75      } //-- org.apache.maven.plugin.lifecycle.io.xpp3.LifecycleMappingsXpp3Reader(ContentTransformer)
76  
77  
78        //-----------/
79       //- Methods -/
80      //-----------/
81  
82      /**
83       * Method checkFieldWithDuplicate.
84       * 
85       * @param parser
86       * @param parsed
87       * @param alias
88       * @param tagName
89       * @throws XmlPullParserException
90       * @return boolean
91       */
92      private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set parsed )
93          throws XmlPullParserException
94      {
95          if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
96          {
97              return false;
98          }
99          if ( !parsed.add( tagName ) )
100         {
101             throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
102         }
103         return true;
104     } //-- boolean checkFieldWithDuplicate( XmlPullParser, String, String, java.util.Set )
105 
106     /**
107      * Method checkUnknownAttribute.
108      * 
109      * @param parser
110      * @param strict
111      * @param tagName
112      * @param attribute
113      * @throws XmlPullParserException
114      * @throws IOException
115      */
116     private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
117         throws XmlPullParserException, IOException
118     {
119         // strictXmlAttributes = true for model: if strict == true, not only elements are checked but attributes too
120         if ( strict )
121         {
122             throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
123         }
124     } //-- void checkUnknownAttribute( XmlPullParser, String, String, boolean )
125 
126     /**
127      * Method checkUnknownElement.
128      * 
129      * @param parser
130      * @param strict
131      * @throws XmlPullParserException
132      * @throws IOException
133      */
134     private void checkUnknownElement( XmlPullParser parser, boolean strict )
135         throws XmlPullParserException, IOException
136     {
137         if ( strict )
138         {
139             throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
140         }
141 
142         for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
143         {
144             int eventType = parser.next();
145             if ( eventType == XmlPullParser.START_TAG )
146             {
147                 unrecognizedTagCount++;
148             }
149             else if ( eventType == XmlPullParser.END_TAG )
150             {
151                 unrecognizedTagCount--;
152             }
153         }
154     } //-- void checkUnknownElement( XmlPullParser, boolean )
155 
156     /**
157      * Returns the state of the "add default entities" flag.
158      * 
159      * @return boolean
160      */
161     public boolean getAddDefaultEntities()
162     {
163         return addDefaultEntities;
164     } //-- boolean getAddDefaultEntities()
165 
166     /**
167      * Method getBooleanValue.
168      * 
169      * @param s
170      * @param parser
171      * @param attribute
172      * @throws XmlPullParserException
173      * @return boolean
174      */
175     private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
176         throws XmlPullParserException
177     {
178         return getBooleanValue( s, attribute, parser, null );
179     } //-- boolean getBooleanValue( String, String, XmlPullParser )
180 
181     /**
182      * Method getBooleanValue.
183      * 
184      * @param s
185      * @param defaultValue
186      * @param parser
187      * @param attribute
188      * @throws XmlPullParserException
189      * @return boolean
190      */
191     private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
192         throws XmlPullParserException
193     {
194         if ( s != null && s.length() != 0 )
195         {
196             return Boolean.valueOf( s ).booleanValue();
197         }
198         if ( defaultValue != null )
199         {
200             return Boolean.valueOf( defaultValue ).booleanValue();
201         }
202         return false;
203     } //-- boolean getBooleanValue( String, String, XmlPullParser, String )
204 
205     /**
206      * Method getByteValue.
207      * 
208      * @param s
209      * @param strict
210      * @param parser
211      * @param attribute
212      * @throws XmlPullParserException
213      * @return byte
214      */
215     private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
216         throws XmlPullParserException
217     {
218         if ( s != null )
219         {
220             try
221             {
222                 return Byte.valueOf( s ).byteValue();
223             }
224             catch ( NumberFormatException nfe )
225             {
226                 if ( strict )
227                 {
228                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
229                 }
230             }
231         }
232         return 0;
233     } //-- byte getByteValue( String, String, XmlPullParser, boolean )
234 
235     /**
236      * Method getCharacterValue.
237      * 
238      * @param s
239      * @param parser
240      * @param attribute
241      * @throws XmlPullParserException
242      * @return char
243      */
244     private char getCharacterValue( String s, String attribute, XmlPullParser parser )
245         throws XmlPullParserException
246     {
247         if ( s != null )
248         {
249             return s.charAt( 0 );
250         }
251         return 0;
252     } //-- char getCharacterValue( String, String, XmlPullParser )
253 
254     /**
255      * Method getDateValue.
256      * 
257      * @param s
258      * @param parser
259      * @param attribute
260      * @throws XmlPullParserException
261      * @return Date
262      */
263     private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
264         throws XmlPullParserException
265     {
266         return getDateValue( s, attribute, null, parser );
267     } //-- java.util.Date getDateValue( String, String, XmlPullParser )
268 
269     /**
270      * Method getDateValue.
271      * 
272      * @param s
273      * @param parser
274      * @param dateFormat
275      * @param attribute
276      * @throws XmlPullParserException
277      * @return Date
278      */
279     private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
280         throws XmlPullParserException
281     {
282         if ( s != null )
283         {
284             String effectiveDateFormat = dateFormat;
285             if ( dateFormat == null )
286             {
287                 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
288             }
289             if ( "long".equals( effectiveDateFormat ) )
290             {
291                 try
292                 {
293                     return new java.util.Date( Long.parseLong( s ) );
294                 }
295                 catch ( NumberFormatException e )
296                 {
297                     throw new XmlPullParserException( e.getMessage(), parser, e );
298                 }
299             }
300             else
301             {
302                 try
303                 {
304                     DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
305                     return dateParser.parse( s );
306                 }
307                 catch ( java.text.ParseException e )
308                 {
309                     throw new XmlPullParserException( e.getMessage(), parser, e );
310                 }
311             }
312         }
313         return null;
314     } //-- java.util.Date getDateValue( String, String, String, XmlPullParser )
315 
316     /**
317      * Method getDoubleValue.
318      * 
319      * @param s
320      * @param strict
321      * @param parser
322      * @param attribute
323      * @throws XmlPullParserException
324      * @return double
325      */
326     private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
327         throws XmlPullParserException
328     {
329         if ( s != null )
330         {
331             try
332             {
333                 return Double.valueOf( s ).doubleValue();
334             }
335             catch ( NumberFormatException nfe )
336             {
337                 if ( strict )
338                 {
339                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
340                 }
341             }
342         }
343         return 0;
344     } //-- double getDoubleValue( String, String, XmlPullParser, boolean )
345 
346     /**
347      * Method getFloatValue.
348      * 
349      * @param s
350      * @param strict
351      * @param parser
352      * @param attribute
353      * @throws XmlPullParserException
354      * @return float
355      */
356     private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
357         throws XmlPullParserException
358     {
359         if ( s != null )
360         {
361             try
362             {
363                 return Float.valueOf( s ).floatValue();
364             }
365             catch ( NumberFormatException nfe )
366             {
367                 if ( strict )
368                 {
369                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
370                 }
371             }
372         }
373         return 0;
374     } //-- float getFloatValue( String, String, XmlPullParser, boolean )
375 
376     /**
377      * Method getIntegerValue.
378      * 
379      * @param s
380      * @param strict
381      * @param parser
382      * @param attribute
383      * @throws XmlPullParserException
384      * @return int
385      */
386     private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
387         throws XmlPullParserException
388     {
389         if ( s != null )
390         {
391             try
392             {
393                 return Integer.valueOf( s ).intValue();
394             }
395             catch ( NumberFormatException nfe )
396             {
397                 if ( strict )
398                 {
399                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
400                 }
401             }
402         }
403         return 0;
404     } //-- int getIntegerValue( String, String, XmlPullParser, boolean )
405 
406     /**
407      * Method getLongValue.
408      * 
409      * @param s
410      * @param strict
411      * @param parser
412      * @param attribute
413      * @throws XmlPullParserException
414      * @return long
415      */
416     private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
417         throws XmlPullParserException
418     {
419         if ( s != null )
420         {
421             try
422             {
423                 return Long.valueOf( s ).longValue();
424             }
425             catch ( NumberFormatException nfe )
426             {
427                 if ( strict )
428                 {
429                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
430                 }
431             }
432         }
433         return 0;
434     } //-- long getLongValue( String, String, XmlPullParser, boolean )
435 
436     /**
437      * Method getRequiredAttributeValue.
438      * 
439      * @param s
440      * @param strict
441      * @param parser
442      * @param attribute
443      * @throws XmlPullParserException
444      * @return String
445      */
446     private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
447         throws XmlPullParserException
448     {
449         if ( s == null )
450         {
451             if ( strict )
452             {
453                 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
454             }
455         }
456         return s;
457     } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean )
458 
459     /**
460      * Method getShortValue.
461      * 
462      * @param s
463      * @param strict
464      * @param parser
465      * @param attribute
466      * @throws XmlPullParserException
467      * @return short
468      */
469     private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
470         throws XmlPullParserException
471     {
472         if ( s != null )
473         {
474             try
475             {
476                 return Short.valueOf( s ).shortValue();
477             }
478             catch ( NumberFormatException nfe )
479             {
480                 if ( strict )
481                 {
482                     throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
483                 }
484             }
485         }
486         return 0;
487     } //-- short getShortValue( String, String, XmlPullParser, boolean )
488 
489     /**
490      * Method getTrimmedValue.
491      * 
492      * @param s
493      * @return String
494      */
495     private String getTrimmedValue( String s )
496     {
497         if ( s != null )
498         {
499             s = s.trim();
500         }
501         return s;
502     } //-- String getTrimmedValue( String )
503 
504     /**
505      * Method interpolatedTrimmed.
506      * 
507      * @param value
508      * @param context
509      * @return String
510      */
511     private String interpolatedTrimmed( String value, String context )
512     {
513         return getTrimmedValue( contentTransformer.transform( value, context ) );
514     } //-- String interpolatedTrimmed( String, String )
515 
516     /**
517      * Method nextTag.
518      * 
519      * @param parser
520      * @throws IOException
521      * @throws XmlPullParserException
522      * @return int
523      */
524     private int nextTag( XmlPullParser parser )
525         throws IOException, XmlPullParserException
526     {
527         int eventType = parser.next();
528         if ( eventType == XmlPullParser.TEXT )
529         {
530             eventType = parser.next();
531         }
532         if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
533         {
534             throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
535         }
536         return eventType;
537     } //-- int nextTag( XmlPullParser )
538 
539     /**
540      * @see ReaderFactory#newXmlReader
541      * 
542      * @param reader
543      * @param strict
544      * @throws IOException
545      * @throws XmlPullParserException
546      * @return LifecycleConfiguration
547      */
548     public LifecycleConfiguration read( Reader reader, boolean strict )
549         throws IOException, XmlPullParserException
550     {
551         XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
552 
553         parser.setInput( reader );
554 
555 
556         return read( parser, strict );
557     } //-- LifecycleConfiguration read( Reader, boolean )
558 
559     /**
560      * @see ReaderFactory#newXmlReader
561      * 
562      * @param reader
563      * @throws IOException
564      * @throws XmlPullParserException
565      * @return LifecycleConfiguration
566      */
567     public LifecycleConfiguration read( Reader reader )
568         throws IOException, XmlPullParserException
569     {
570         return read( reader, true );
571     } //-- LifecycleConfiguration read( Reader )
572 
573     /**
574      * Method read.
575      * 
576      * @param in
577      * @param strict
578      * @throws IOException
579      * @throws XmlPullParserException
580      * @return LifecycleConfiguration
581      */
582     public LifecycleConfiguration read( InputStream in, boolean strict )
583         throws IOException, XmlPullParserException
584     {
585         return read( ReaderFactory.newXmlReader( in ), strict );
586     } //-- LifecycleConfiguration read( InputStream, boolean )
587 
588     /**
589      * Method read.
590      * 
591      * @param in
592      * @throws IOException
593      * @throws XmlPullParserException
594      * @return LifecycleConfiguration
595      */
596     public LifecycleConfiguration read( InputStream in )
597         throws IOException, XmlPullParserException
598     {
599         return read( ReaderFactory.newXmlReader( in ) );
600     } //-- LifecycleConfiguration read( InputStream )
601 
602     /**
603      * Method parseExecution.
604      * 
605      * @param parser
606      * @param strict
607      * @throws IOException
608      * @throws XmlPullParserException
609      * @return Execution
610      */
611     private Execution parseExecution( XmlPullParser parser, boolean strict )
612         throws IOException, XmlPullParserException
613     {
614         String tagName = parser.getName();
615         Execution execution = new Execution();
616         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
617         {
618             String name = parser.getAttributeName( i );
619             String value = parser.getAttributeValue( i );
620 
621             if ( name.indexOf( ':' ) >= 0 )
622             {
623                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
624             }
625             else
626             {
627                 checkUnknownAttribute( parser, name, tagName, strict );
628             }
629         }
630         java.util.Set parsed = new java.util.HashSet();
631         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
632         {
633             if ( checkFieldWithDuplicate( parser, "configuration", null, parsed ) )
634             {
635                 execution.setConfiguration( org.codehaus.plexus.util.xml.Xpp3DomBuilder.build( parser, true ) );
636             }
637             else if ( checkFieldWithDuplicate( parser, "goals", null, parsed ) )
638             {
639                 java.util.List goals = new java.util.ArrayList/*<String>*/();
640                 execution.setGoals( goals );
641                 while ( parser.nextTag() == XmlPullParser.START_TAG )
642                 {
643                     if ( "goal".equals( parser.getName() ) )
644                     {
645                         goals.add( interpolatedTrimmed( parser.nextText(), "goals" ) );
646                     }
647                     else
648                     {
649                         checkUnknownElement( parser, strict );
650                     }
651                 }
652             }
653             else
654             {
655                 checkUnknownElement( parser, strict );
656             }
657         }
658         return execution;
659     } //-- Execution parseExecution( XmlPullParser, boolean )
660 
661     /**
662      * Method parseLifecycle.
663      * 
664      * @param parser
665      * @param strict
666      * @throws IOException
667      * @throws XmlPullParserException
668      * @return Lifecycle
669      */
670     private Lifecycle parseLifecycle( XmlPullParser parser, boolean strict )
671         throws IOException, XmlPullParserException
672     {
673         String tagName = parser.getName();
674         Lifecycle lifecycle = new Lifecycle();
675         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
676         {
677             String name = parser.getAttributeName( i );
678             String value = parser.getAttributeValue( i );
679 
680             if ( name.indexOf( ':' ) >= 0 )
681             {
682                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
683             }
684             else
685             {
686                 checkUnknownAttribute( parser, name, tagName, strict );
687             }
688         }
689         java.util.Set parsed = new java.util.HashSet();
690         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
691         {
692             if ( checkFieldWithDuplicate( parser, "id", null, parsed ) )
693             {
694                 lifecycle.setId( interpolatedTrimmed( parser.nextText(), "id" ) );
695             }
696             else if ( checkFieldWithDuplicate( parser, "phases", null, parsed ) )
697             {
698                 java.util.List phases = new java.util.ArrayList/*<Phase>*/();
699                 lifecycle.setPhases( phases );
700                 while ( parser.nextTag() == XmlPullParser.START_TAG )
701                 {
702                     if ( "phase".equals( parser.getName() ) )
703                     {
704                         phases.add( parsePhase( parser, strict ) );
705                     }
706                     else
707                     {
708                         checkUnknownElement( parser, strict );
709                     }
710                 }
711             }
712             else
713             {
714                 checkUnknownElement( parser, strict );
715             }
716         }
717         return lifecycle;
718     } //-- Lifecycle parseLifecycle( XmlPullParser, boolean )
719 
720     /**
721      * Method parseLifecycleConfiguration.
722      * 
723      * @param parser
724      * @param strict
725      * @throws IOException
726      * @throws XmlPullParserException
727      * @return LifecycleConfiguration
728      */
729     private LifecycleConfiguration parseLifecycleConfiguration( XmlPullParser parser, boolean strict )
730         throws IOException, XmlPullParserException
731     {
732         String tagName = parser.getName();
733         LifecycleConfiguration lifecycleConfiguration = new LifecycleConfiguration();
734         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
735         {
736             String name = parser.getAttributeName( i );
737             String value = parser.getAttributeValue( i );
738 
739             if ( name.indexOf( ':' ) >= 0 )
740             {
741                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
742             }
743             else if ( "xmlns".equals( name ) )
744             {
745                 // ignore xmlns attribute in root class, which is a reserved attribute name
746             }
747             else
748             {
749                 checkUnknownAttribute( parser, name, tagName, strict );
750             }
751         }
752         java.util.Set parsed = new java.util.HashSet();
753         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
754         {
755             if ( "lifecycle".equals( parser.getName() ) )
756             {
757                 java.util.List lifecycles = lifecycleConfiguration.getLifecycles();
758                 if ( lifecycles == null )
759                 {
760                     lifecycles = new java.util.ArrayList/*<Lifecycle>*/();
761                     lifecycleConfiguration.setLifecycles( lifecycles );
762                 }
763                 lifecycles.add( parseLifecycle( parser, strict ) );
764             }
765             else
766             {
767                 checkUnknownElement( parser, strict );
768             }
769         }
770         return lifecycleConfiguration;
771     } //-- LifecycleConfiguration parseLifecycleConfiguration( XmlPullParser, boolean )
772 
773     /**
774      * Method parsePhase.
775      * 
776      * @param parser
777      * @param strict
778      * @throws IOException
779      * @throws XmlPullParserException
780      * @return Phase
781      */
782     private Phase parsePhase( XmlPullParser parser, boolean strict )
783         throws IOException, XmlPullParserException
784     {
785         String tagName = parser.getName();
786         Phase phase = new Phase();
787         for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
788         {
789             String name = parser.getAttributeName( i );
790             String value = parser.getAttributeValue( i );
791 
792             if ( name.indexOf( ':' ) >= 0 )
793             {
794                 // just ignore attributes with non-default namespace (for example: xmlns:xsi)
795             }
796             else
797             {
798                 checkUnknownAttribute( parser, name, tagName, strict );
799             }
800         }
801         java.util.Set parsed = new java.util.HashSet();
802         while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
803         {
804             if ( checkFieldWithDuplicate( parser, "id", null, parsed ) )
805             {
806                 phase.setId( interpolatedTrimmed( parser.nextText(), "id" ) );
807             }
808             else if ( checkFieldWithDuplicate( parser, "executions", null, parsed ) )
809             {
810                 java.util.List executions = new java.util.ArrayList/*<Execution>*/();
811                 phase.setExecutions( executions );
812                 while ( parser.nextTag() == XmlPullParser.START_TAG )
813                 {
814                     if ( "execution".equals( parser.getName() ) )
815                     {
816                         executions.add( parseExecution( parser, strict ) );
817                     }
818                     else
819                     {
820                         checkUnknownElement( parser, strict );
821                     }
822                 }
823             }
824             else if ( checkFieldWithDuplicate( parser, "configuration", null, parsed ) )
825             {
826                 phase.setConfiguration( org.codehaus.plexus.util.xml.Xpp3DomBuilder.build( parser, true ) );
827             }
828             else
829             {
830                 checkUnknownElement( parser, strict );
831             }
832         }
833         return phase;
834     } //-- Phase parsePhase( XmlPullParser, boolean )
835 
836     /**
837      * Method read.
838      * 
839      * @param parser
840      * @param strict
841      * @throws IOException
842      * @throws XmlPullParserException
843      * @return LifecycleConfiguration
844      */
845     private LifecycleConfiguration read( XmlPullParser parser, boolean strict )
846         throws IOException, XmlPullParserException
847     {
848         int eventType = parser.getEventType();
849         while ( eventType != XmlPullParser.END_DOCUMENT )
850         {
851             if ( eventType == XmlPullParser.START_TAG )
852             {
853                 if ( strict && ! "lifecycles".equals( parser.getName() ) )
854                 {
855                     throw new XmlPullParserException( "Expected root element 'lifecycles' but found '" + parser.getName() + "'", parser, null );
856                 }
857                 LifecycleConfiguration lifecycleConfiguration = parseLifecycleConfiguration( parser, strict );
858                 lifecycleConfiguration.setModelEncoding( parser.getInputEncoding() );
859                 return lifecycleConfiguration;
860             }
861             eventType = parser.next();
862         }
863         throw new XmlPullParserException( "Expected root element 'lifecycles' but found no element at all: invalid XML document", parser, null );
864     } //-- LifecycleConfiguration read( XmlPullParser, boolean )
865 
866     /**
867      * Sets the state of the "add default entities" flag.
868      * 
869      * @param addDefaultEntities
870      */
871     public void setAddDefaultEntities( boolean addDefaultEntities )
872     {
873         this.addDefaultEntities = addDefaultEntities;
874     } //-- void setAddDefaultEntities( boolean )
875 
876     public static interface ContentTransformer
877 {
878     /**
879      * Interpolate the value read from the xpp3 document
880      * @param source The source value
881      * @param fieldName A description of the field being interpolated. The implementation may use this to
882      *                           log stuff.
883      * @return The interpolated value.
884      */
885     String transform( String source, String fieldName );
886 }
887 
888 }