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