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