1
2
3
4
5
6
7
8 package org.apache.continuum.release.model.io.stax;
9
10
11
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
34
35
36
37 @SuppressWarnings( "all" )
38 public class ContinuumPrepareReleasesModelStaxReader
39 {
40
41
42
43
44
45
46
47
48
49
50
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
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 }
121
122
123
124
125
126
127
128
129
130
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 }
146
147
148
149
150
151
152
153
154
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 }
165
166
167
168
169
170
171
172
173
174
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 }
195
196
197
198
199
200
201
202
203
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 }
214
215
216
217
218
219
220
221
222
223
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 }
261
262
263
264
265
266
267
268
269 private String getDefaultValue( String s, String v )
270 {
271 if ( s == null )
272 {
273 s = v;
274 }
275 return s;
276 }
277
278
279
280
281
282
283
284
285
286
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 }
307
308
309
310
311
312
313
314
315
316
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 }
337
338
339
340
341
342
343
344
345
346
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 }
367
368
369
370
371
372
373
374
375
376
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 }
397
398
399
400
401
402
403
404
405
406
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 }
420
421
422
423
424
425
426
427
428
429
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 }
450
451
452
453
454
455
456
457 private String getTrimmedValue( String s )
458 {
459 if ( s != null )
460 {
461 s = s.trim();
462 }
463 return s;
464 }
465
466
467
468
469
470
471
472
473
474
475
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 }
534
535
536
537
538
539
540
541
542
543
544
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
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 }
592
593
594
595
596
597
598
599
600
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 }
612
613
614
615
616
617
618
619
620
621 public PreparedReleaseModel read( Reader reader )
622 throws IOException, XMLStreamException
623 {
624 return read( reader, true );
625 }
626
627
628
629
630
631
632
633
634
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 }
647
648
649
650
651
652
653
654
655
656 public PreparedReleaseModel read( String filePath )
657 throws IOException, XMLStreamException
658 {
659 return read( filePath, true );
660 }
661
662
663
664
665
666
667 private void resolveReferences( PreparedReleaseModel value )
668 {
669 java.util.Map refs;
670 }
671
672 }