View Javadoc

1   /*
2    =================== DO NOT EDIT THIS FILE ====================
3    Generated by Modello
4    any modifications will be overwritten.
5    ==============================================================
6    */
7   
8   package org.apache.continuum.release.model.io.stax;
9   
10    //---------------------------------/
11   //- Imported classes and packages -/
12  //---------------------------------/
13  
14  import java.io.ByteArrayInputStream;
15  import java.io.File;
16  import java.io.FileInputStream;
17  import java.io.IOException;
18  import java.io.InputStreamReader;
19  import java.io.Reader;
20  import java.io.StringReader;
21  import java.io.StringWriter;
22  import java.text.DateFormat;
23  import java.text.ParsePosition;
24  import java.util.Locale;
25  import java.util.regex.Matcher;
26  import java.util.regex.Pattern;
27  import javax.xml.stream.*;
28  import org.apache.continuum.release.model.PreparedRelease;
29  import org.apache.continuum.release.model.PreparedReleaseModel;
30  import org.codehaus.plexus.util.xml.Xpp3Dom;
31  
32  /**
33   * Class ContinuumPrepareReleasesModelStaxReader.
34   * 
35   * @version $Revision$ $Date$
36   */
37  @SuppressWarnings( "all" )
38  public class ContinuumPrepareReleasesModelStaxReader
39  {
40  
41        //-----------/
42       //- Methods -/
43      //-----------/
44  
45      /**
46       * Method buildDom.
47       * 
48       * @param xmlStreamReader
49       * @throws XMLStreamException
50       * @return Xpp3Dom
51       */
52      private Xpp3Dom buildDom( XMLStreamReader xmlStreamReader )
53          throws XMLStreamException
54      {
55          java.util.List elements = new java.util.ArrayList();
56          java.util.List values = new java.util.ArrayList();
57          int eventType = xmlStreamReader.getEventType();
58          while ( xmlStreamReader.hasNext() )
59          {
60              if ( eventType == XMLStreamConstants.START_ELEMENT )
61              {
62                  String rawName = xmlStreamReader.getLocalName();
63                  Xpp3Dom childConfiguration = new Xpp3Dom( rawName );
64                  int depth = elements.size();
65                  if ( depth > 0 )
66                  {
67                      Xpp3Dom parent = (Xpp3Dom) elements.get( depth - 1 );
68                      parent.addChild( childConfiguration );
69                  }
70                  elements.add( childConfiguration );
71                  if ( xmlStreamReader.isEndElement() )
72                  {
73                      values.add( null );
74                  }
75                  else
76                  {
77                      values.add( new StringBuffer() );
78                  }
79                  int attributesSize = xmlStreamReader.getAttributeCount();
80                  for ( int i = 0; i < attributesSize; i++ )
81                  {
82                      String name = xmlStreamReader.getAttributeLocalName( i );
83                      String value = xmlStreamReader.getAttributeValue( i );
84                      childConfiguration.setAttribute( name, value );
85                  }
86              }
87              else if ( eventType == XMLStreamConstants.CHARACTERS )
88              {
89                  int depth = values.size() - 1;
90                  StringBuffer valueBuffer = (StringBuffer) values.get( depth );
91                  String text = xmlStreamReader.getText();
92                  text = text.trim();
93                  valueBuffer.append( text );
94              }
95              else if ( eventType == XMLStreamConstants.END_ELEMENT )
96              {
97                  int depth = elements.size() - 1;
98                  Xpp3Dom finishedConfiguration = (Xpp3Dom) elements.remove( depth );
99                  // this Object could be null if it is a singleton tag
100                 Object accumulatedValue = values.remove( depth );
101                 if ( finishedConfiguration.getChildCount() == 0 )
102                 {
103                     if ( accumulatedValue == null )
104                     {
105                         finishedConfiguration.setValue( null );
106                     }
107                     else
108                     {
109                         finishedConfiguration.setValue( accumulatedValue.toString() );
110                     }
111                 }
112                 if ( depth == 0 )
113                 {
114                     return finishedConfiguration;
115                 }
116             }
117             eventType = xmlStreamReader.next();
118         }
119         throw new IllegalStateException( "End of document found before returning to 0 depth" );
120     } //-- Xpp3Dom buildDom( XMLStreamReader )
121 
122     /**
123      * Method checkFieldWithDuplicate.
124      * 
125      * @param xmlStreamReader
126      * @param parsed
127      * @param alias
128      * @param tagName
129      * @throws XMLStreamException
130      * @return boolean
131      */
132     private boolean checkFieldWithDuplicate( XMLStreamReader xmlStreamReader, String tagName, String alias, java.util.Set parsed )
133         throws XMLStreamException
134     {
135         if ( !( xmlStreamReader.getLocalName().equals( tagName ) || xmlStreamReader.getLocalName().equals( alias ) ) )
136         {
137             return false;
138         }
139         if ( parsed.contains( tagName ) )
140         {
141             throw new XMLStreamException( "Duplicated tag: '" + tagName + "'", xmlStreamReader.getLocation() );
142         }
143         parsed.add( tagName );
144         return true;
145     } //-- boolean checkFieldWithDuplicate( XMLStreamReader, String, String, java.util.Set )
146 
147     /**
148      * Method getBooleanValue.
149      * 
150      * @param s
151      * @param xmlStreamReader
152      * @param attribute
153      * @throws XMLStreamException
154      * @return boolean
155      */
156     private boolean getBooleanValue( String s, String attribute, XMLStreamReader xmlStreamReader )
157         throws XMLStreamException
158     {
159         if ( s != null )
160         {
161             return Boolean.valueOf( s ).booleanValue();
162         }
163         return false;
164     } //-- boolean getBooleanValue( String, String, XMLStreamReader )
165 
166     /**
167      * Method getByteValue.
168      * 
169      * @param s
170      * @param strict
171      * @param xmlStreamReader
172      * @param attribute
173      * @throws XMLStreamException
174      * @return byte
175      */
176     private byte getByteValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
177         throws XMLStreamException
178     {
179         if ( s != null )
180         {
181             try
182             {
183                 return Byte.valueOf( s ).byteValue();
184             }
185             catch ( NumberFormatException e )
186             {
187                 if ( strict )
188                 {
189                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a byte but was '" + s + "'", xmlStreamReader.getLocation() );
190                 }
191             }
192         }
193         return 0;
194     } //-- byte getByteValue( String, String, XMLStreamReader, boolean )
195 
196     /**
197      * Method getCharacterValue.
198      * 
199      * @param s
200      * @param xmlStreamReader
201      * @param attribute
202      * @throws XMLStreamException
203      * @return char
204      */
205     private char getCharacterValue( String s, String attribute, XMLStreamReader xmlStreamReader )
206         throws XMLStreamException
207     {
208         if ( s != null )
209         {
210             return s.charAt( 0 );
211         }
212         return 0;
213     } //-- char getCharacterValue( String, String, XMLStreamReader )
214 
215     /**
216      * Method getDateValue.
217      * 
218      * @param s
219      * @param xmlStreamReader
220      * @param dateFormat
221      * @param attribute
222      * @throws XMLStreamException
223      * @return Date
224      */
225     private java.util.Date getDateValue( String s, String attribute, String dateFormat, XMLStreamReader xmlStreamReader )
226         throws XMLStreamException
227     {
228         if ( s != null )
229         {
230             String effectiveDateFormat = dateFormat;
231             if ( dateFormat == null )
232             {
233                 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
234             }
235             if ( "long".equals( effectiveDateFormat ) )
236             {
237                 try
238                 {
239                     return new java.util.Date( Long.parseLong( s ) );
240                 }
241                 catch ( NumberFormatException e )
242                 {
243                     throw new XMLStreamException( e.getMessage() );
244                 }
245             }
246             else
247             {
248                 try
249                 {
250                     DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, Locale.US );
251                     return dateParser.parse( s );
252                 }
253                 catch ( java.text.ParseException e )
254                 {
255                     throw new XMLStreamException( e.getMessage() );
256                 }
257             }
258         }
259         return null;
260     } //-- java.util.Date getDateValue( String, String, String, XMLStreamReader )
261 
262     /**
263      * Method getDefaultValue.
264      * 
265      * @param s
266      * @param v
267      * @return String
268      */
269     private String getDefaultValue( String s, String v )
270     {
271         if ( s == null )
272         {
273             s = v;
274         }
275         return s;
276     } //-- String getDefaultValue( String, String )
277 
278     /**
279      * Method getDoubleValue.
280      * 
281      * @param s
282      * @param strict
283      * @param xmlStreamReader
284      * @param attribute
285      * @throws XMLStreamException
286      * @return double
287      */
288     private double getDoubleValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
289         throws XMLStreamException
290     {
291         if ( s != null )
292         {
293             try
294             {
295                 return Double.valueOf( s ).doubleValue();
296             }
297             catch ( NumberFormatException e )
298             {
299                 if ( strict )
300                 {
301                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
302                 }
303             }
304         }
305         return 0;
306     } //-- double getDoubleValue( String, String, XMLStreamReader, boolean )
307 
308     /**
309      * Method getFloatValue.
310      * 
311      * @param s
312      * @param strict
313      * @param xmlStreamReader
314      * @param attribute
315      * @throws XMLStreamException
316      * @return float
317      */
318     private float getFloatValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
319         throws XMLStreamException
320     {
321         if ( s != null )
322         {
323             try
324             {
325                 return Float.valueOf( s ).floatValue();
326             }
327             catch ( NumberFormatException e )
328             {
329                 if ( strict )
330                 {
331                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation() );
332                 }
333             }
334         }
335         return 0;
336     } //-- float getFloatValue( String, String, XMLStreamReader, boolean )
337 
338     /**
339      * Method getIntegerValue.
340      * 
341      * @param s
342      * @param strict
343      * @param xmlStreamReader
344      * @param attribute
345      * @throws XMLStreamException
346      * @return int
347      */
348     private int getIntegerValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
349         throws XMLStreamException
350     {
351         if ( s != null )
352         {
353             try
354             {
355                 return Integer.valueOf( s ).intValue();
356             }
357             catch ( NumberFormatException e )
358             {
359                 if ( strict )
360                 {
361                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be an integer but was '" + s + "'", xmlStreamReader.getLocation() );
362                 }
363             }
364         }
365         return 0;
366     } //-- int getIntegerValue( String, String, XMLStreamReader, boolean )
367 
368     /**
369      * Method getLongValue.
370      * 
371      * @param s
372      * @param strict
373      * @param xmlStreamReader
374      * @param attribute
375      * @throws XMLStreamException
376      * @return long
377      */
378     private long getLongValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
379         throws XMLStreamException
380     {
381         if ( s != null )
382         {
383             try
384             {
385                 return Long.valueOf( s ).longValue();
386             }
387             catch ( NumberFormatException e )
388             {
389                 if ( strict )
390                 {
391                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a long integer but was '" + s + "'", xmlStreamReader.getLocation() );
392                 }
393             }
394         }
395         return 0;
396     } //-- long getLongValue( String, String, XMLStreamReader, boolean )
397 
398     /**
399      * Method getRequiredAttributeValue.
400      * 
401      * @param s
402      * @param strict
403      * @param xmlStreamReader
404      * @param attribute
405      * @throws XMLStreamException
406      * @return String
407      */
408     private String getRequiredAttributeValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
409         throws XMLStreamException
410     {
411         if ( s == null )
412         {
413             if ( strict )
414             {
415                 throw new XMLStreamException( "Missing required value for attribute '" + attribute + "'", xmlStreamReader.getLocation() );
416             }
417         }
418         return s;
419     } //-- String getRequiredAttributeValue( String, String, XMLStreamReader, boolean )
420 
421     /**
422      * Method getShortValue.
423      * 
424      * @param s
425      * @param strict
426      * @param xmlStreamReader
427      * @param attribute
428      * @throws XMLStreamException
429      * @return short
430      */
431     private short getShortValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
432         throws XMLStreamException
433     {
434         if ( s != null )
435         {
436             try
437             {
438                 return Short.valueOf( s ).shortValue();
439             }
440             catch ( NumberFormatException e )
441             {
442                 if ( strict )
443                 {
444                     throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a short integer but was '" + s + "'", xmlStreamReader.getLocation() );
445                 }
446             }
447         }
448         return 0;
449     } //-- short getShortValue( String, String, XMLStreamReader, boolean )
450 
451     /**
452      * Method getTrimmedValue.
453      * 
454      * @param s
455      * @return String
456      */
457     private String getTrimmedValue( String s )
458     {
459         if ( s != null )
460         {
461             s = s.trim();
462         }
463         return s;
464     } //-- String getTrimmedValue( String )
465 
466     /**
467      * Method parsePreparedRelease.
468      * 
469      * @param tagName
470      * @param encoding
471      * @param strict
472      * @param xmlStreamReader
473      * @throws IOException
474      * @throws XMLStreamException
475      * @return PreparedRelease
476      */
477     private PreparedRelease parsePreparedRelease( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
478         throws IOException, XMLStreamException
479     {
480         PreparedRelease preparedRelease = new PreparedRelease();
481         java.util.Set parsed = new java.util.HashSet();
482         while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
483         {
484             if ( checkFieldWithDuplicate( xmlStreamReader, "releaseId", null, parsed ) )
485             {
486                 preparedRelease.setReleaseId( getTrimmedValue( xmlStreamReader.getElementText() ) );
487             }
488             else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseName", null, parsed ) )
489             {
490                 preparedRelease.setReleaseName( getTrimmedValue( xmlStreamReader.getElementText() ) );
491             }
492             else if ( checkFieldWithDuplicate( xmlStreamReader, "buildAgentUrl", null, parsed ) )
493             {
494                 preparedRelease.setBuildAgentUrl( getTrimmedValue( xmlStreamReader.getElementText() ) );
495             }
496             else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseType", null, parsed ) )
497             {
498                 preparedRelease.setReleaseType( getTrimmedValue( xmlStreamReader.getElementText() ) );
499             }
500             else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseGoals", null, parsed ) )
501             {
502                 preparedRelease.setReleaseGoals( getTrimmedValue( xmlStreamReader.getElementText() ) );
503             }
504             else if ( checkFieldWithDuplicate( xmlStreamReader, "releaseBy", null, parsed ) )
505             {
506                 preparedRelease.setReleaseBy( getTrimmedValue( xmlStreamReader.getElementText() ) );
507             }
508             else
509             {
510                 if ( strict )
511                 {
512                     throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
513                 }
514                 else
515                 {
516                     int unrecognizedTagCount = 1;
517                     while( unrecognizedTagCount != 0 )
518                     {
519                         xmlStreamReader.next();
520                         if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
521                         {
522                             unrecognizedTagCount++;
523                         }
524                         else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
525                         {
526                             unrecognizedTagCount--;
527                         }
528                     }
529                 }
530             }
531         }
532         return preparedRelease;
533     } //-- PreparedRelease parsePreparedRelease( String, XMLStreamReader, boolean, String )
534 
535     /**
536      * Method parsePreparedReleaseModel.
537      * 
538      * @param tagName
539      * @param encoding
540      * @param strict
541      * @param xmlStreamReader
542      * @throws IOException
543      * @throws XMLStreamException
544      * @return PreparedReleaseModel
545      */
546     private PreparedReleaseModel parsePreparedReleaseModel( String tagName, XMLStreamReader xmlStreamReader, boolean strict, String encoding )
547         throws IOException, XMLStreamException
548     {
549         PreparedReleaseModel preparedReleaseModel = new PreparedReleaseModel();
550         java.util.Set parsed = new java.util.HashSet();
551         preparedReleaseModel.setModelEncoding( encoding );
552         boolean foundRoot = false;
553         while ( xmlStreamReader.hasNext() )
554         {
555             int eventType = xmlStreamReader.next();
556             if ( eventType == XMLStreamConstants.START_ELEMENT )
557             {
558                 if ( xmlStreamReader.getLocalName().equals( tagName ) )
559                 {
560                     foundRoot = true;
561                 }
562                 else if ( checkFieldWithDuplicate( xmlStreamReader, "preparedReleases", null, parsed ) )
563                 {
564                     java.util.List preparedReleases = new java.util.ArrayList/*<PreparedRelease>*/();
565                     preparedReleaseModel.setPreparedReleases( preparedReleases );
566                     while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
567                     {
568                         if ( xmlStreamReader.getLocalName().equals( "preparedRelease" ) )
569                         {
570                             preparedReleaseModel.addPreparedRelease( parsePreparedRelease( "preparedRelease", xmlStreamReader, strict, encoding ) );
571                         }
572                         else
573                         {
574                             throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
575                         }
576                     }
577                 }
578                 else
579                 {
580                     if ( foundRoot )
581                     {
582                         if ( strict )
583                         {
584                             throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
585                         }
586                     }
587                 }
588             }
589         }
590         return preparedReleaseModel;
591     } //-- PreparedReleaseModel parsePreparedReleaseModel( String, XMLStreamReader, boolean, String )
592 
593     /**
594      * Method read.
595      * 
596      * @param reader
597      * @param strict
598      * @throws IOException
599      * @throws XMLStreamException
600      * @return PreparedReleaseModel
601      */
602     public PreparedReleaseModel read( Reader reader, boolean strict )
603         throws IOException, XMLStreamException
604     {
605         XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );
606 
607         String encoding = xmlStreamReader.getCharacterEncodingScheme();
608         PreparedReleaseModel value = parsePreparedReleaseModel( "prepared-releases", xmlStreamReader, strict, encoding );
609         resolveReferences( value );
610         return value;
611     } //-- PreparedReleaseModel read( Reader, boolean )
612 
613     /**
614      * Method read.
615      * 
616      * @param reader
617      * @throws IOException
618      * @throws XMLStreamException
619      * @return PreparedReleaseModel
620      */
621     public PreparedReleaseModel read( Reader reader )
622         throws IOException, XMLStreamException
623     {
624         return read( reader, true );
625     } //-- PreparedReleaseModel read( Reader )
626 
627     /**
628      * Method read.
629      * 
630      * @param filePath
631      * @param strict
632      * @throws IOException
633      * @throws XMLStreamException
634      * @return PreparedReleaseModel
635      */
636     public PreparedReleaseModel read( String filePath, boolean strict )
637         throws IOException, XMLStreamException
638     {
639         File file = new File(filePath);
640         XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( file.toURL().toExternalForm(), new FileInputStream(file) );
641 
642         String encoding = xmlStreamReader.getCharacterEncodingScheme();
643         PreparedReleaseModel value = parsePreparedReleaseModel( "prepared-releases", xmlStreamReader, strict, encoding );
644         resolveReferences( value );
645         return value;
646     } //-- PreparedReleaseModel read( String, boolean )
647 
648     /**
649      * Method read.
650      * 
651      * @param filePath
652      * @throws IOException
653      * @throws XMLStreamException
654      * @return PreparedReleaseModel
655      */
656     public PreparedReleaseModel read( String filePath )
657         throws IOException, XMLStreamException
658     {
659         return read( filePath, true );
660     } //-- PreparedReleaseModel read( String )
661 
662     /**
663      * Method resolveReferences.
664      * 
665      * @param value
666      */
667     private void resolveReferences( PreparedReleaseModel value )
668     {
669         java.util.Map refs;
670     } //-- void resolveReferences( PreparedReleaseModel )
671 
672 }