Source code

001// =================== DO NOT EDIT THIS FILE ====================
002// Generated by Modello 1.8.3,
003// any modifications will be overwritten.
004// ==============================================================
005
006package org.apache.maven.usability.plugin.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.usability.plugin.Expression;
017import org.apache.maven.usability.plugin.ExpressionDocumentation;
018import org.codehaus.plexus.util.ReaderFactory;
019import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
020import org.codehaus.plexus.util.xml.pull.MXParser;
021import org.codehaus.plexus.util.xml.pull.XmlPullParser;
022import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
023
024/**
025 * Class ParamdocXpp3Reader.
026 * 
027 * @version $Revision: 965443 $ $Date: 2015-09-14 22:18:52 +0000 (Mon, 14 Sep 2015) $
028 */
029@SuppressWarnings( "all" )
030public class ParamdocXpp3Reader
031{
032
033      //--------------------------/
034     //- Class/Member Variables -/
035    //--------------------------/
036
037    /**
038     * If set the parser will be loaded with all single characters
039     * from the XHTML specification.
040     * The entities used:
041     * <ul>
042     * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent</li>
043     * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent</li>
044     * <li>http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent</li>
045     * </ul>
046     */
047    private boolean addDefaultEntities = true;
048
049    /**
050     * Field contentTransformer.
051     */
052    public final ContentTransformer contentTransformer;
053
054
055      //----------------/
056     //- Constructors -/
057    //----------------/
058
059    public ParamdocXpp3Reader()
060    {
061        this( new ContentTransformer()
062        {
063            public String transform( String source, String fieldName )
064            {
065                return source;
066            }
067        } );
068    } //-- org.apache.maven.usability.plugin.io.xpp3.ParamdocXpp3Reader()
069
070    public ParamdocXpp3Reader(ContentTransformer contentTransformer)
071    {
072        this.contentTransformer = contentTransformer;
073    } //-- org.apache.maven.usability.plugin.io.xpp3.ParamdocXpp3Reader(ContentTransformer)
074
075
076      //-----------/
077     //- Methods -/
078    //-----------/
079
080    /**
081     * Method checkFieldWithDuplicate.
082     * 
083     * @param parser
084     * @param parsed
085     * @param alias
086     * @param tagName
087     * @throws XmlPullParserException
088     * @return boolean
089     */
090    private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set parsed )
091        throws XmlPullParserException
092    {
093        if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
094        {
095            return false;
096        }
097        if ( !parsed.add( tagName ) )
098        {
099            throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
100        }
101        return true;
102    } //-- boolean checkFieldWithDuplicate( XmlPullParser, String, String, java.util.Set )
103
104    /**
105     * Method checkUnknownAttribute.
106     * 
107     * @param parser
108     * @param strict
109     * @param tagName
110     * @param attribute
111     * @throws XmlPullParserException
112     * @throws IOException
113     */
114    private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
115        throws XmlPullParserException, IOException
116    {
117        // strictXmlAttributes = true for model: if strict == true, not only elements are checked but attributes too
118        if ( strict )
119        {
120            throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
121        }
122    } //-- void checkUnknownAttribute( XmlPullParser, String, String, boolean )
123
124    /**
125     * Method checkUnknownElement.
126     * 
127     * @param parser
128     * @param strict
129     * @throws XmlPullParserException
130     * @throws IOException
131     */
132    private void checkUnknownElement( XmlPullParser parser, boolean strict )
133        throws XmlPullParserException, IOException
134    {
135        if ( strict )
136        {
137            throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
138        }
139
140        for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
141        {
142            int eventType = parser.next();
143            if ( eventType == XmlPullParser.START_TAG )
144            {
145                unrecognizedTagCount++;
146            }
147            else if ( eventType == XmlPullParser.END_TAG )
148            {
149                unrecognizedTagCount--;
150            }
151        }
152    } //-- void checkUnknownElement( XmlPullParser, boolean )
153
154    /**
155     * Returns the state of the "add default entities" flag.
156     * 
157     * @return boolean
158     */
159    public boolean getAddDefaultEntities()
160    {
161        return addDefaultEntities;
162    } //-- boolean getAddDefaultEntities()
163
164    /**
165     * Method getBooleanValue.
166     * 
167     * @param s
168     * @param parser
169     * @param attribute
170     * @throws XmlPullParserException
171     * @return boolean
172     */
173    private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
174        throws XmlPullParserException
175    {
176        return getBooleanValue( s, attribute, parser, null );
177    } //-- boolean getBooleanValue( String, String, XmlPullParser )
178
179    /**
180     * Method getBooleanValue.
181     * 
182     * @param s
183     * @param defaultValue
184     * @param parser
185     * @param attribute
186     * @throws XmlPullParserException
187     * @return boolean
188     */
189    private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
190        throws XmlPullParserException
191    {
192        if ( s != null && s.length() != 0 )
193        {
194            return Boolean.valueOf( s ).booleanValue();
195        }
196        if ( defaultValue != null )
197        {
198            return Boolean.valueOf( defaultValue ).booleanValue();
199        }
200        return false;
201    } //-- boolean getBooleanValue( String, String, XmlPullParser, String )
202
203    /**
204     * Method getByteValue.
205     * 
206     * @param s
207     * @param strict
208     * @param parser
209     * @param attribute
210     * @throws XmlPullParserException
211     * @return byte
212     */
213    private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
214        throws XmlPullParserException
215    {
216        if ( s != null )
217        {
218            try
219            {
220                return Byte.valueOf( s ).byteValue();
221            }
222            catch ( NumberFormatException nfe )
223            {
224                if ( strict )
225                {
226                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
227                }
228            }
229        }
230        return 0;
231    } //-- byte getByteValue( String, String, XmlPullParser, boolean )
232
233    /**
234     * Method getCharacterValue.
235     * 
236     * @param s
237     * @param parser
238     * @param attribute
239     * @throws XmlPullParserException
240     * @return char
241     */
242    private char getCharacterValue( String s, String attribute, XmlPullParser parser )
243        throws XmlPullParserException
244    {
245        if ( s != null )
246        {
247            return s.charAt( 0 );
248        }
249        return 0;
250    } //-- char getCharacterValue( String, String, XmlPullParser )
251
252    /**
253     * Method getDateValue.
254     * 
255     * @param s
256     * @param parser
257     * @param attribute
258     * @throws XmlPullParserException
259     * @return Date
260     */
261    private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
262        throws XmlPullParserException
263    {
264        return getDateValue( s, attribute, null, parser );
265    } //-- java.util.Date getDateValue( String, String, XmlPullParser )
266
267    /**
268     * Method getDateValue.
269     * 
270     * @param s
271     * @param parser
272     * @param dateFormat
273     * @param attribute
274     * @throws XmlPullParserException
275     * @return Date
276     */
277    private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
278        throws XmlPullParserException
279    {
280        if ( s != null )
281        {
282            String effectiveDateFormat = dateFormat;
283            if ( dateFormat == null )
284            {
285                effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
286            }
287            if ( "long".equals( effectiveDateFormat ) )
288            {
289                try
290                {
291                    return new java.util.Date( Long.parseLong( s ) );
292                }
293                catch ( NumberFormatException e )
294                {
295                    throw new XmlPullParserException( e.getMessage(), parser, e );
296                }
297            }
298            else
299            {
300                try
301                {
302                    DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
303                    return dateParser.parse( s );
304                }
305                catch ( java.text.ParseException e )
306                {
307                    throw new XmlPullParserException( e.getMessage(), parser, e );
308                }
309            }
310        }
311        return null;
312    } //-- java.util.Date getDateValue( String, String, String, XmlPullParser )
313
314    /**
315     * Method getDoubleValue.
316     * 
317     * @param s
318     * @param strict
319     * @param parser
320     * @param attribute
321     * @throws XmlPullParserException
322     * @return double
323     */
324    private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
325        throws XmlPullParserException
326    {
327        if ( s != null )
328        {
329            try
330            {
331                return Double.valueOf( s ).doubleValue();
332            }
333            catch ( NumberFormatException nfe )
334            {
335                if ( strict )
336                {
337                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
338                }
339            }
340        }
341        return 0;
342    } //-- double getDoubleValue( String, String, XmlPullParser, boolean )
343
344    /**
345     * Method getFloatValue.
346     * 
347     * @param s
348     * @param strict
349     * @param parser
350     * @param attribute
351     * @throws XmlPullParserException
352     * @return float
353     */
354    private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
355        throws XmlPullParserException
356    {
357        if ( s != null )
358        {
359            try
360            {
361                return Float.valueOf( s ).floatValue();
362            }
363            catch ( NumberFormatException nfe )
364            {
365                if ( strict )
366                {
367                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
368                }
369            }
370        }
371        return 0;
372    } //-- float getFloatValue( String, String, XmlPullParser, boolean )
373
374    /**
375     * Method getIntegerValue.
376     * 
377     * @param s
378     * @param strict
379     * @param parser
380     * @param attribute
381     * @throws XmlPullParserException
382     * @return int
383     */
384    private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
385        throws XmlPullParserException
386    {
387        if ( s != null )
388        {
389            try
390            {
391                return Integer.valueOf( s ).intValue();
392            }
393            catch ( NumberFormatException nfe )
394            {
395                if ( strict )
396                {
397                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
398                }
399            }
400        }
401        return 0;
402    } //-- int getIntegerValue( String, String, XmlPullParser, boolean )
403
404    /**
405     * Method getLongValue.
406     * 
407     * @param s
408     * @param strict
409     * @param parser
410     * @param attribute
411     * @throws XmlPullParserException
412     * @return long
413     */
414    private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
415        throws XmlPullParserException
416    {
417        if ( s != null )
418        {
419            try
420            {
421                return Long.valueOf( s ).longValue();
422            }
423            catch ( NumberFormatException nfe )
424            {
425                if ( strict )
426                {
427                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
428                }
429            }
430        }
431        return 0;
432    } //-- long getLongValue( String, String, XmlPullParser, boolean )
433
434    /**
435     * Method getRequiredAttributeValue.
436     * 
437     * @param s
438     * @param strict
439     * @param parser
440     * @param attribute
441     * @throws XmlPullParserException
442     * @return String
443     */
444    private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
445        throws XmlPullParserException
446    {
447        if ( s == null )
448        {
449            if ( strict )
450            {
451                throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
452            }
453        }
454        return s;
455    } //-- String getRequiredAttributeValue( String, String, XmlPullParser, boolean )
456
457    /**
458     * Method getShortValue.
459     * 
460     * @param s
461     * @param strict
462     * @param parser
463     * @param attribute
464     * @throws XmlPullParserException
465     * @return short
466     */
467    private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
468        throws XmlPullParserException
469    {
470        if ( s != null )
471        {
472            try
473            {
474                return Short.valueOf( s ).shortValue();
475            }
476            catch ( NumberFormatException nfe )
477            {
478                if ( strict )
479                {
480                    throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
481                }
482            }
483        }
484        return 0;
485    } //-- short getShortValue( String, String, XmlPullParser, boolean )
486
487    /**
488     * Method getTrimmedValue.
489     * 
490     * @param s
491     * @return String
492     */
493    private String getTrimmedValue( String s )
494    {
495        if ( s != null )
496        {
497            s = s.trim();
498        }
499        return s;
500    } //-- String getTrimmedValue( String )
501
502    /**
503     * Method interpolatedTrimmed.
504     * 
505     * @param value
506     * @param context
507     * @return String
508     */
509    private String interpolatedTrimmed( String value, String context )
510    {
511        return getTrimmedValue( contentTransformer.transform( value, context ) );
512    } //-- String interpolatedTrimmed( String, String )
513
514    /**
515     * Method nextTag.
516     * 
517     * @param parser
518     * @throws IOException
519     * @throws XmlPullParserException
520     * @return int
521     */
522    private int nextTag( XmlPullParser parser )
523        throws IOException, XmlPullParserException
524    {
525        int eventType = parser.next();
526        if ( eventType == XmlPullParser.TEXT )
527        {
528            eventType = parser.next();
529        }
530        if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
531        {
532            throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
533        }
534        return eventType;
535    } //-- int nextTag( XmlPullParser )
536
537    /**
538     * @see ReaderFactory#newXmlReader
539     * 
540     * @param reader
541     * @param strict
542     * @throws IOException
543     * @throws XmlPullParserException
544     * @return ExpressionDocumentation
545     */
546    public ExpressionDocumentation read( Reader reader, boolean strict )
547        throws IOException, XmlPullParserException
548    {
549        XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
550
551        parser.setInput( reader );
552
553
554        return read( parser, strict );
555    } //-- ExpressionDocumentation read( Reader, boolean )
556
557    /**
558     * @see ReaderFactory#newXmlReader
559     * 
560     * @param reader
561     * @throws IOException
562     * @throws XmlPullParserException
563     * @return ExpressionDocumentation
564     */
565    public ExpressionDocumentation read( Reader reader )
566        throws IOException, XmlPullParserException
567    {
568        return read( reader, true );
569    } //-- ExpressionDocumentation read( Reader )
570
571    /**
572     * Method read.
573     * 
574     * @param in
575     * @param strict
576     * @throws IOException
577     * @throws XmlPullParserException
578     * @return ExpressionDocumentation
579     */
580    public ExpressionDocumentation read( InputStream in, boolean strict )
581        throws IOException, XmlPullParserException
582    {
583        return read( ReaderFactory.newXmlReader( in ), strict );
584    } //-- ExpressionDocumentation read( InputStream, boolean )
585
586    /**
587     * Method read.
588     * 
589     * @param in
590     * @throws IOException
591     * @throws XmlPullParserException
592     * @return ExpressionDocumentation
593     */
594    public ExpressionDocumentation read( InputStream in )
595        throws IOException, XmlPullParserException
596    {
597        return read( ReaderFactory.newXmlReader( in ) );
598    } //-- ExpressionDocumentation read( InputStream )
599
600    /**
601     * Method parseExpression.
602     * 
603     * @param parser
604     * @param strict
605     * @throws IOException
606     * @throws XmlPullParserException
607     * @return Expression
608     */
609    private Expression parseExpression( XmlPullParser parser, boolean strict )
610        throws IOException, XmlPullParserException
611    {
612        String tagName = parser.getName();
613        Expression expression = new Expression();
614        for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
615        {
616            String name = parser.getAttributeName( i );
617            String value = parser.getAttributeValue( i );
618
619            if ( name.indexOf( ':' ) >= 0 )
620            {
621                // just ignore attributes with non-default namespace (for example: xmlns:xsi)
622            }
623            else
624            {
625                checkUnknownAttribute( parser, name, tagName, strict );
626            }
627        }
628        java.util.Set parsed = new java.util.HashSet();
629        while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
630        {
631            if ( checkFieldWithDuplicate( parser, "syntax", null, parsed ) )
632            {
633                expression.setSyntax( interpolatedTrimmed( parser.nextText(), "syntax" ) );
634            }
635            else if ( checkFieldWithDuplicate( parser, "description", null, parsed ) )
636            {
637                expression.setDescription( interpolatedTrimmed( parser.nextText(), "description" ) );
638            }
639            else if ( checkFieldWithDuplicate( parser, "configuration", null, parsed ) )
640            {
641                expression.setConfiguration( interpolatedTrimmed( parser.nextText(), "configuration" ) );
642            }
643            else if ( checkFieldWithDuplicate( parser, "cliOptions", null, parsed ) )
644            {
645                while ( parser.nextTag() == XmlPullParser.START_TAG )
646                {
647                    if ( "cliOption".equals( parser.getName() ) )
648                    {
649                        String key = null;
650                        String value = null;
651                        // explode mode.
652                        while ( parser.nextTag() == XmlPullParser.START_TAG )
653                        {
654                            if ( "key".equals( parser.getName() ) )
655                            {
656                                key = parser.nextText();
657                            }
658                            else if ( "value".equals( parser.getName() ) )
659                            {
660                                value = parser.nextText().trim();
661                            }
662                            else
663                            {
664                                parser.nextText();
665                            }
666                        }
667                        expression.addCliOption( key, value );
668                    }
669                    parser.next();
670                }
671            }
672            else if ( checkFieldWithDuplicate( parser, "apiMethods", null, parsed ) )
673            {
674                while ( parser.nextTag() == XmlPullParser.START_TAG )
675                {
676                    if ( "apiMethod".equals( parser.getName() ) )
677                    {
678                        String key = null;
679                        String value = null;
680                        // explode mode.
681                        while ( parser.nextTag() == XmlPullParser.START_TAG )
682                        {
683                            if ( "key".equals( parser.getName() ) )
684                            {
685                                key = parser.nextText();
686                            }
687                            else if ( "value".equals( parser.getName() ) )
688                            {
689                                value = parser.nextText().trim();
690                            }
691                            else
692                            {
693                                parser.nextText();
694                            }
695                        }
696                        expression.addApiMethod( key, value );
697                    }
698                    parser.next();
699                }
700            }
701            else if ( checkFieldWithDuplicate( parser, "deprecation", null, parsed ) )
702            {
703                expression.setDeprecation( interpolatedTrimmed( parser.nextText(), "deprecation" ) );
704            }
705            else if ( checkFieldWithDuplicate( parser, "ban", null, parsed ) )
706            {
707                expression.setBan( interpolatedTrimmed( parser.nextText(), "ban" ) );
708            }
709            else if ( checkFieldWithDuplicate( parser, "editable", null, parsed ) )
710            {
711                expression.setEditable( getBooleanValue( interpolatedTrimmed( parser.nextText(), "editable" ), "editable", parser, "true" ) );
712            }
713            else
714            {
715                checkUnknownElement( parser, strict );
716            }
717        }
718        return expression;
719    } //-- Expression parseExpression( XmlPullParser, boolean )
720
721    /**
722     * Method parseExpressionDocumentation.
723     * 
724     * @param parser
725     * @param strict
726     * @throws IOException
727     * @throws XmlPullParserException
728     * @return ExpressionDocumentation
729     */
730    private ExpressionDocumentation parseExpressionDocumentation( XmlPullParser parser, boolean strict )
731        throws IOException, XmlPullParserException
732    {
733        String tagName = parser.getName();
734        ExpressionDocumentation expressionDocumentation = new ExpressionDocumentation();
735        for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
736        {
737            String name = parser.getAttributeName( i );
738            String value = parser.getAttributeValue( i );
739
740            if ( name.indexOf( ':' ) >= 0 )
741            {
742                // just ignore attributes with non-default namespace (for example: xmlns:xsi)
743            }
744            else if ( "xmlns".equals( name ) )
745            {
746                // ignore xmlns attribute in root class, which is a reserved attribute name
747            }
748            else
749            {
750                checkUnknownAttribute( parser, name, tagName, strict );
751            }
752        }
753        java.util.Set parsed = new java.util.HashSet();
754        while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
755        {
756            if ( checkFieldWithDuplicate( parser, "expressions", null, parsed ) )
757            {
758                java.util.List expressions = new java.util.ArrayList/*<Expression>*/();
759                expressionDocumentation.setExpressions( expressions );
760                while ( parser.nextTag() == XmlPullParser.START_TAG )
761                {
762                    if ( "expression".equals( parser.getName() ) )
763                    {
764                        expressions.add( parseExpression( parser, strict ) );
765                    }
766                    else
767                    {
768                        checkUnknownElement( parser, strict );
769                    }
770                }
771            }
772            else
773            {
774                checkUnknownElement( parser, strict );
775            }
776        }
777        return expressionDocumentation;
778    } //-- ExpressionDocumentation parseExpressionDocumentation( XmlPullParser, boolean )
779
780    /**
781     * Method read.
782     * 
783     * @param parser
784     * @param strict
785     * @throws IOException
786     * @throws XmlPullParserException
787     * @return ExpressionDocumentation
788     */
789    private ExpressionDocumentation read( XmlPullParser parser, boolean strict )
790        throws IOException, XmlPullParserException
791    {
792        int eventType = parser.getEventType();
793        while ( eventType != XmlPullParser.END_DOCUMENT )
794        {
795            if ( eventType == XmlPullParser.START_TAG )
796            {
797                if ( strict && ! "paramdoc".equals( parser.getName() ) )
798                {
799                    throw new XmlPullParserException( "Expected root element 'paramdoc' but found '" + parser.getName() + "'", parser, null );
800                }
801                ExpressionDocumentation expressionDocumentation = parseExpressionDocumentation( parser, strict );
802                expressionDocumentation.setModelEncoding( parser.getInputEncoding() );
803                return expressionDocumentation;
804            }
805            eventType = parser.next();
806        }
807        throw new XmlPullParserException( "Expected root element 'paramdoc' but found no element at all: invalid XML document", parser, null );
808    } //-- ExpressionDocumentation read( XmlPullParser, boolean )
809
810    /**
811     * Sets the state of the "add default entities" flag.
812     * 
813     * @param addDefaultEntities
814     */
815    public void setAddDefaultEntities( boolean addDefaultEntities )
816    {
817        this.addDefaultEntities = addDefaultEntities;
818    } //-- void setAddDefaultEntities( boolean )
819
820    public static interface ContentTransformer
821{
822    /**
823     * Interpolate the value read from the xpp3 document
824     * @param source The source value
825     * @param fieldName A description of the field being interpolated. The implementation may use this to
826     *                           log stuff.
827     * @return The interpolated value.
828     */
829    String transform( String source, String fieldName );
830}
831
832}