1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 package org.apache.maven.plugins.javadoc.options.io.xpp3;
25
26
27
28
29
30 import java.io.IOException;
31 import java.io.InputStream;
32 import java.io.Reader;
33 import java.text.DateFormat;
34 import org.apache.maven.plugins.javadoc.options.BootclasspathArtifact;
35 import org.apache.maven.plugins.javadoc.options.DocletArtifact;
36 import org.apache.maven.plugins.javadoc.options.Group;
37 import org.apache.maven.plugins.javadoc.options.JavadocOptions;
38 import org.apache.maven.plugins.javadoc.options.JavadocPathArtifact;
39 import org.apache.maven.plugins.javadoc.options.OfflineLink;
40 import org.apache.maven.plugins.javadoc.options.ResourcesArtifact;
41 import org.apache.maven.plugins.javadoc.options.Tag;
42 import org.apache.maven.plugins.javadoc.options.Taglet;
43 import org.apache.maven.plugins.javadoc.options.TagletArtifact;
44 import org.codehaus.plexus.util.xml.XmlStreamReader;
45 import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
46 import org.codehaus.plexus.util.xml.pull.MXParser;
47 import org.codehaus.plexus.util.xml.pull.XmlPullParser;
48 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
49
50
51
52
53
54
55 @SuppressWarnings( "all" )
56 public class JavadocOptionsXpp3Reader
57 {
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73 private boolean addDefaultEntities = true;
74
75
76
77
78 public final ContentTransformer contentTransformer;
79
80
81
82
83
84
85 public JavadocOptionsXpp3Reader()
86 {
87 this( new ContentTransformer()
88 {
89 public String transform( String source, String fieldName )
90 {
91 return source;
92 }
93 } );
94 }
95
96 public JavadocOptionsXpp3Reader(ContentTransformer contentTransformer)
97 {
98 this.contentTransformer = contentTransformer;
99 }
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117 private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set<String> parsed )
118 throws XmlPullParserException
119 {
120 if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
121 {
122 return false;
123 }
124 if ( !parsed.add( tagName ) )
125 {
126 throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
127 }
128 return true;
129 }
130
131
132
133
134
135
136
137
138
139
140
141
142 private void checkUnknownAttribute( XmlPullParser parser, String attribute, String tagName, boolean strict )
143 throws XmlPullParserException, IOException
144 {
145
146 if ( strict )
147 {
148 throw new XmlPullParserException( "Unknown attribute '" + attribute + "' for tag '" + tagName + "'", parser, null );
149 }
150 }
151
152
153
154
155
156
157
158
159
160
161 private void checkUnknownElement( XmlPullParser parser, boolean strict )
162 throws XmlPullParserException, IOException
163 {
164 if ( strict )
165 {
166 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
167 }
168
169 for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
170 {
171 int eventType = parser.next();
172 if ( eventType == XmlPullParser.START_TAG )
173 {
174 unrecognizedTagCount++;
175 }
176 else if ( eventType == XmlPullParser.END_TAG )
177 {
178 unrecognizedTagCount--;
179 }
180 }
181 }
182
183
184
185
186
187
188 public boolean getAddDefaultEntities()
189 {
190 return addDefaultEntities;
191 }
192
193
194
195
196
197
198
199
200
201
202
203 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
204 throws XmlPullParserException
205 {
206 return getBooleanValue( s, attribute, parser, null );
207 }
208
209
210
211
212
213
214
215
216
217
218
219
220 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
221 throws XmlPullParserException
222 {
223 if ( s != null && s.length() != 0 )
224 {
225 return Boolean.valueOf( s ).booleanValue();
226 }
227 if ( defaultValue != null )
228 {
229 return Boolean.valueOf( defaultValue ).booleanValue();
230 }
231 return false;
232 }
233
234
235
236
237
238
239
240
241
242
243
244
245 private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
246 throws XmlPullParserException
247 {
248 if ( s != null )
249 {
250 try
251 {
252 return Byte.valueOf( s ).byteValue();
253 }
254 catch ( NumberFormatException nfe )
255 {
256 if ( strict )
257 {
258 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
259 }
260 }
261 }
262 return 0;
263 }
264
265
266
267
268
269
270
271
272
273
274
275 private char getCharacterValue( String s, String attribute, XmlPullParser parser )
276 throws XmlPullParserException
277 {
278 if ( s != null )
279 {
280 return s.charAt( 0 );
281 }
282 return 0;
283 }
284
285
286
287
288
289
290
291
292
293
294
295 private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
296 throws XmlPullParserException
297 {
298 return getDateValue( s, attribute, null, parser );
299 }
300
301
302
303
304
305
306
307
308
309
310
311
312 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
313 throws XmlPullParserException
314 {
315 if ( s != null )
316 {
317 String effectiveDateFormat = dateFormat;
318 if ( dateFormat == null )
319 {
320 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
321 }
322 if ( "long".equals( effectiveDateFormat ) )
323 {
324 try
325 {
326 return new java.util.Date( Long.parseLong( s ) );
327 }
328 catch ( NumberFormatException e )
329 {
330 throw new XmlPullParserException( e.getMessage(), parser, e );
331 }
332 }
333 else
334 {
335 try
336 {
337 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
338 return dateParser.parse( s );
339 }
340 catch ( java.text.ParseException e )
341 {
342 throw new XmlPullParserException( e.getMessage(), parser, e );
343 }
344 }
345 }
346 return null;
347 }
348
349
350
351
352
353
354
355
356
357
358
359
360 private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
361 throws XmlPullParserException
362 {
363 if ( s != null )
364 {
365 try
366 {
367 return Double.valueOf( s ).doubleValue();
368 }
369 catch ( NumberFormatException nfe )
370 {
371 if ( strict )
372 {
373 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
374 }
375 }
376 }
377 return 0;
378 }
379
380
381
382
383
384
385
386
387
388
389
390
391 private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
392 throws XmlPullParserException
393 {
394 if ( s != null )
395 {
396 try
397 {
398 return Float.valueOf( s ).floatValue();
399 }
400 catch ( NumberFormatException nfe )
401 {
402 if ( strict )
403 {
404 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
405 }
406 }
407 }
408 return 0;
409 }
410
411
412
413
414
415
416
417
418
419
420
421
422 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
423 throws XmlPullParserException
424 {
425 if ( s != null )
426 {
427 try
428 {
429 return Integer.valueOf( s ).intValue();
430 }
431 catch ( NumberFormatException nfe )
432 {
433 if ( strict )
434 {
435 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
436 }
437 }
438 }
439 return 0;
440 }
441
442
443
444
445
446
447
448
449
450
451
452
453 private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
454 throws XmlPullParserException
455 {
456 if ( s != null )
457 {
458 try
459 {
460 return Long.valueOf( s ).longValue();
461 }
462 catch ( NumberFormatException nfe )
463 {
464 if ( strict )
465 {
466 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
467 }
468 }
469 }
470 return 0;
471 }
472
473
474
475
476
477
478
479
480
481
482
483
484 private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
485 throws XmlPullParserException
486 {
487 if ( s == null )
488 {
489 if ( strict )
490 {
491 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
492 }
493 }
494 return s;
495 }
496
497
498
499
500
501
502
503
504
505
506
507
508 private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
509 throws XmlPullParserException
510 {
511 if ( s != null )
512 {
513 try
514 {
515 return Short.valueOf( s ).shortValue();
516 }
517 catch ( NumberFormatException nfe )
518 {
519 if ( strict )
520 {
521 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
522 }
523 }
524 }
525 return 0;
526 }
527
528
529
530
531
532
533
534 private String getTrimmedValue( String s )
535 {
536 if ( s != null )
537 {
538 s = s.trim();
539 }
540 return s;
541 }
542
543
544
545
546
547
548
549
550 private String interpolatedTrimmed( String value, String context )
551 {
552 return getTrimmedValue( contentTransformer.transform( value, context ) );
553 }
554
555
556
557
558
559
560
561
562
563
564 private int nextTag( XmlPullParser parser )
565 throws IOException, XmlPullParserException
566 {
567 int eventType = parser.next();
568 if ( eventType == XmlPullParser.TEXT )
569 {
570 eventType = parser.next();
571 }
572 if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
573 {
574 throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
575 }
576 return eventType;
577 }
578
579
580
581
582
583
584
585
586
587
588
589 public JavadocOptions read( XmlPullParser parser, boolean strict )
590 throws IOException, XmlPullParserException
591 {
592 JavadocOptions javadocOptions = null;
593 int eventType = parser.getEventType();
594 boolean parsed = false;
595 while ( eventType != XmlPullParser.END_DOCUMENT )
596 {
597 if ( eventType == XmlPullParser.START_TAG )
598 {
599 if ( strict && ! "javadocOptions".equals( parser.getName() ) )
600 {
601 throw new XmlPullParserException( "Expected root element 'javadocOptions' but found '" + parser.getName() + "'", parser, null );
602 }
603 else if ( parsed )
604 {
605
606 throw new XmlPullParserException( "Duplicated tag: 'javadocOptions'", parser, null );
607 }
608 javadocOptions = parseJavadocOptions( parser, strict );
609 javadocOptions.setModelEncoding( parser.getInputEncoding() );
610 parsed = true;
611 }
612 eventType = parser.next();
613 }
614 if ( parsed )
615 {
616 return javadocOptions;
617 }
618 throw new XmlPullParserException( "Expected root element 'javadocOptions' but found no element at all: invalid XML document", parser, null );
619 }
620
621
622
623
624
625
626
627
628
629
630
631 public JavadocOptions read( Reader reader, boolean strict )
632 throws IOException, XmlPullParserException
633 {
634 XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
635
636 parser.setInput( reader );
637
638
639 return read( parser, strict );
640 }
641
642
643
644
645
646
647
648
649
650
651 public JavadocOptions read( Reader reader )
652 throws IOException, XmlPullParserException
653 {
654 return read( reader, true );
655 }
656
657
658
659
660
661
662
663
664
665
666
667 public JavadocOptions read( InputStream in, boolean strict )
668 throws IOException, XmlPullParserException
669 {
670 return read( new XmlStreamReader( in ), strict );
671 }
672
673
674
675
676
677
678
679
680
681
682 public JavadocOptions read( InputStream in )
683 throws IOException, XmlPullParserException
684 {
685 return read( new XmlStreamReader( in ) );
686 }
687
688
689
690
691
692
693
694
695
696
697
698 private BootclasspathArtifact parseBootclasspathArtifact( XmlPullParser parser, boolean strict )
699 throws IOException, XmlPullParserException
700 {
701 String tagName = parser.getName();
702 BootclasspathArtifact bootclasspathArtifact = new BootclasspathArtifact();
703 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
704 {
705 String name = parser.getAttributeName( i );
706 String value = parser.getAttributeValue( i );
707
708 if ( name.indexOf( ':' ) >= 0 )
709 {
710
711 }
712 else
713 {
714 checkUnknownAttribute( parser, name, tagName, strict );
715 }
716 }
717 java.util.Set<String> parsed = new java.util.HashSet<String>();
718 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
719 {
720 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) )
721 {
722 bootclasspathArtifact.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
723 }
724 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) )
725 {
726 bootclasspathArtifact.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
727 }
728 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
729 {
730 bootclasspathArtifact.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) );
731 }
732 else if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) )
733 {
734 bootclasspathArtifact.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
735 }
736 else
737 {
738 checkUnknownElement( parser, strict );
739 }
740 }
741 return bootclasspathArtifact;
742 }
743
744
745
746
747
748
749
750
751
752
753
754 private DocletArtifact parseDocletArtifact( XmlPullParser parser, boolean strict )
755 throws IOException, XmlPullParserException
756 {
757 String tagName = parser.getName();
758 DocletArtifact docletArtifact = new DocletArtifact();
759 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
760 {
761 String name = parser.getAttributeName( i );
762 String value = parser.getAttributeValue( i );
763
764 if ( name.indexOf( ':' ) >= 0 )
765 {
766
767 }
768 else
769 {
770 checkUnknownAttribute( parser, name, tagName, strict );
771 }
772 }
773 java.util.Set<String> parsed = new java.util.HashSet<String>();
774 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
775 {
776 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) )
777 {
778 docletArtifact.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
779 }
780 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) )
781 {
782 docletArtifact.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
783 }
784 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
785 {
786 docletArtifact.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) );
787 }
788 else if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) )
789 {
790 docletArtifact.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
791 }
792 else
793 {
794 checkUnknownElement( parser, strict );
795 }
796 }
797 return docletArtifact;
798 }
799
800
801
802
803
804
805
806
807
808
809
810 private Group parseGroup( XmlPullParser parser, boolean strict )
811 throws IOException, XmlPullParserException
812 {
813 String tagName = parser.getName();
814 Group group = new Group();
815 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
816 {
817 String name = parser.getAttributeName( i );
818 String value = parser.getAttributeValue( i );
819
820 if ( name.indexOf( ':' ) >= 0 )
821 {
822
823 }
824 else
825 {
826 checkUnknownAttribute( parser, name, tagName, strict );
827 }
828 }
829 java.util.Set<String> parsed = new java.util.HashSet<String>();
830 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
831 {
832 if ( checkFieldWithDuplicate( parser, "title", null, parsed ) )
833 {
834 group.setTitle( interpolatedTrimmed( parser.nextText(), "title" ) );
835 }
836 else if ( checkFieldWithDuplicate( parser, "packages", null, parsed ) )
837 {
838 group.setPackages( interpolatedTrimmed( parser.nextText(), "packages" ) );
839 }
840 else
841 {
842 checkUnknownElement( parser, strict );
843 }
844 }
845 return group;
846 }
847
848
849
850
851
852
853
854
855
856
857
858 private JavadocOptions parseJavadocOptions( XmlPullParser parser, boolean strict )
859 throws IOException, XmlPullParserException
860 {
861 String tagName = parser.getName();
862 JavadocOptions javadocOptions = new JavadocOptions();
863 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
864 {
865 String name = parser.getAttributeName( i );
866 String value = parser.getAttributeValue( i );
867
868 if ( name.indexOf( ':' ) >= 0 )
869 {
870
871 }
872 else if ( "xmlns".equals( name ) )
873 {
874
875 }
876 else
877 {
878 checkUnknownAttribute( parser, name, tagName, strict );
879 }
880 }
881 java.util.Set<String> parsed = new java.util.HashSet<String>();
882 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
883 {
884 if ( checkFieldWithDuplicate( parser, "groups", null, parsed ) )
885 {
886 java.util.List<Group> groups = new java.util.ArrayList<Group>();
887 while ( parser.nextTag() == XmlPullParser.START_TAG )
888 {
889 if ( "group".equals( parser.getName() ) )
890 {
891 groups.add( parseGroup( parser, strict ) );
892 }
893 else
894 {
895 checkUnknownElement( parser, strict );
896 }
897 }
898 javadocOptions.setGroups( groups );
899 }
900 else if ( checkFieldWithDuplicate( parser, "tags", null, parsed ) )
901 {
902 java.util.List<Tag> tags = new java.util.ArrayList<Tag>();
903 while ( parser.nextTag() == XmlPullParser.START_TAG )
904 {
905 if ( "tag".equals( parser.getName() ) )
906 {
907 tags.add( parseTag( parser, strict ) );
908 }
909 else
910 {
911 checkUnknownElement( parser, strict );
912 }
913 }
914 javadocOptions.setTags( tags );
915 }
916 else if ( checkFieldWithDuplicate( parser, "docletArtifacts", null, parsed ) )
917 {
918 java.util.List<DocletArtifact> docletArtifacts = new java.util.ArrayList<DocletArtifact>();
919 while ( parser.nextTag() == XmlPullParser.START_TAG )
920 {
921 if ( "docletArtifact".equals( parser.getName() ) )
922 {
923 docletArtifacts.add( parseDocletArtifact( parser, strict ) );
924 }
925 else
926 {
927 checkUnknownElement( parser, strict );
928 }
929 }
930 javadocOptions.setDocletArtifacts( docletArtifacts );
931 }
932 else if ( checkFieldWithDuplicate( parser, "taglets", null, parsed ) )
933 {
934 java.util.List<Taglet> taglets = new java.util.ArrayList<Taglet>();
935 while ( parser.nextTag() == XmlPullParser.START_TAG )
936 {
937 if ( "taglet".equals( parser.getName() ) )
938 {
939 taglets.add( parseTaglet( parser, strict ) );
940 }
941 else
942 {
943 checkUnknownElement( parser, strict );
944 }
945 }
946 javadocOptions.setTaglets( taglets );
947 }
948 else if ( checkFieldWithDuplicate( parser, "offlineLinks", null, parsed ) )
949 {
950 java.util.List<OfflineLink> offlineLinks = new java.util.ArrayList<OfflineLink>();
951 while ( parser.nextTag() == XmlPullParser.START_TAG )
952 {
953 if ( "offlineLink".equals( parser.getName() ) )
954 {
955 offlineLinks.add( parseOfflineLink( parser, strict ) );
956 }
957 else
958 {
959 checkUnknownElement( parser, strict );
960 }
961 }
962 javadocOptions.setOfflineLinks( offlineLinks );
963 }
964 else if ( checkFieldWithDuplicate( parser, "tagletArtifacts", null, parsed ) )
965 {
966 java.util.List<TagletArtifact> tagletArtifacts = new java.util.ArrayList<TagletArtifact>();
967 while ( parser.nextTag() == XmlPullParser.START_TAG )
968 {
969 if ( "tagletArtifact".equals( parser.getName() ) )
970 {
971 tagletArtifacts.add( parseTagletArtifact( parser, strict ) );
972 }
973 else
974 {
975 checkUnknownElement( parser, strict );
976 }
977 }
978 javadocOptions.setTagletArtifacts( tagletArtifacts );
979 }
980 else if ( checkFieldWithDuplicate( parser, "resourcesArtifacts", null, parsed ) )
981 {
982 java.util.List<ResourcesArtifact> resourcesArtifacts = new java.util.ArrayList<ResourcesArtifact>();
983 while ( parser.nextTag() == XmlPullParser.START_TAG )
984 {
985 if ( "resourcesArtifact".equals( parser.getName() ) )
986 {
987 resourcesArtifacts.add( parseResourcesArtifact( parser, strict ) );
988 }
989 else
990 {
991 checkUnknownElement( parser, strict );
992 }
993 }
994 javadocOptions.setResourcesArtifacts( resourcesArtifacts );
995 }
996 else if ( checkFieldWithDuplicate( parser, "bootclasspathArtifacts", null, parsed ) )
997 {
998 java.util.List<BootclasspathArtifact> bootclasspathArtifacts = new java.util.ArrayList<BootclasspathArtifact>();
999 while ( parser.nextTag() == XmlPullParser.START_TAG )
1000 {
1001 if ( "bootclasspathArtifact".equals( parser.getName() ) )
1002 {
1003 bootclasspathArtifacts.add( parseBootclasspathArtifact( parser, strict ) );
1004 }
1005 else
1006 {
1007 checkUnknownElement( parser, strict );
1008 }
1009 }
1010 javadocOptions.setBootclasspathArtifacts( bootclasspathArtifacts );
1011 }
1012 else if ( checkFieldWithDuplicate( parser, "links", null, parsed ) )
1013 {
1014 java.util.List<String> links = new java.util.ArrayList<String>();
1015 while ( parser.nextTag() == XmlPullParser.START_TAG )
1016 {
1017 if ( "link".equals( parser.getName() ) )
1018 {
1019 links.add( interpolatedTrimmed( parser.nextText(), "links" ) );
1020 }
1021 else
1022 {
1023 checkUnknownElement( parser, strict );
1024 }
1025 }
1026 javadocOptions.setLinks( links );
1027 }
1028 else if ( checkFieldWithDuplicate( parser, "excludePackageNames", null, parsed ) )
1029 {
1030 java.util.List<String> excludePackageNames = new java.util.ArrayList<String>();
1031 while ( parser.nextTag() == XmlPullParser.START_TAG )
1032 {
1033 if ( "excludePackageName".equals( parser.getName() ) )
1034 {
1035 excludePackageNames.add( interpolatedTrimmed( parser.nextText(), "excludePackageNames" ) );
1036 }
1037 else
1038 {
1039 checkUnknownElement( parser, strict );
1040 }
1041 }
1042 javadocOptions.setExcludePackageNames( excludePackageNames );
1043 }
1044 else if ( checkFieldWithDuplicate( parser, "docfilesSubdirsUsed", null, parsed ) )
1045 {
1046 javadocOptions.setDocfilesSubdirsUsed( getBooleanValue( interpolatedTrimmed( parser.nextText(), "docfilesSubdirsUsed" ), "docfilesSubdirsUsed", parser, "false" ) );
1047 }
1048 else if ( checkFieldWithDuplicate( parser, "excludedDocfilesSubdirs", null, parsed ) )
1049 {
1050 javadocOptions.setExcludedDocfilesSubdirs( interpolatedTrimmed( parser.nextText(), "excludedDocfilesSubdirs" ) );
1051 }
1052 else if ( checkFieldWithDuplicate( parser, "javadocResourcesDirectory", null, parsed ) )
1053 {
1054 javadocOptions.setJavadocResourcesDirectory( interpolatedTrimmed( parser.nextText(), "javadocResourcesDirectory" ) );
1055 }
1056 else
1057 {
1058 checkUnknownElement( parser, strict );
1059 }
1060 }
1061 return javadocOptions;
1062 }
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074 private JavadocPathArtifact parseJavadocPathArtifact( XmlPullParser parser, boolean strict )
1075 throws IOException, XmlPullParserException
1076 {
1077 String tagName = parser.getName();
1078 JavadocPathArtifact javadocPathArtifact = new JavadocPathArtifact();
1079 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1080 {
1081 String name = parser.getAttributeName( i );
1082 String value = parser.getAttributeValue( i );
1083
1084 if ( name.indexOf( ':' ) >= 0 )
1085 {
1086
1087 }
1088 else
1089 {
1090 checkUnknownAttribute( parser, name, tagName, strict );
1091 }
1092 }
1093 java.util.Set<String> parsed = new java.util.HashSet<String>();
1094 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1095 {
1096 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) )
1097 {
1098 javadocPathArtifact.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1099 }
1100 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) )
1101 {
1102 javadocPathArtifact.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1103 }
1104 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
1105 {
1106 javadocPathArtifact.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) );
1107 }
1108 else if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) )
1109 {
1110 javadocPathArtifact.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
1111 }
1112 else
1113 {
1114 checkUnknownElement( parser, strict );
1115 }
1116 }
1117 return javadocPathArtifact;
1118 }
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130 private OfflineLink parseOfflineLink( XmlPullParser parser, boolean strict )
1131 throws IOException, XmlPullParserException
1132 {
1133 String tagName = parser.getName();
1134 OfflineLink offlineLink = new OfflineLink();
1135 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1136 {
1137 String name = parser.getAttributeName( i );
1138 String value = parser.getAttributeValue( i );
1139
1140 if ( name.indexOf( ':' ) >= 0 )
1141 {
1142
1143 }
1144 else
1145 {
1146 checkUnknownAttribute( parser, name, tagName, strict );
1147 }
1148 }
1149 java.util.Set<String> parsed = new java.util.HashSet<String>();
1150 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1151 {
1152 if ( checkFieldWithDuplicate( parser, "url", null, parsed ) )
1153 {
1154 offlineLink.setUrl( interpolatedTrimmed( parser.nextText(), "url" ) );
1155 }
1156 else if ( checkFieldWithDuplicate( parser, "location", null, parsed ) )
1157 {
1158 offlineLink.setLocation( interpolatedTrimmed( parser.nextText(), "location" ) );
1159 }
1160 else
1161 {
1162 checkUnknownElement( parser, strict );
1163 }
1164 }
1165 return offlineLink;
1166 }
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178 private ResourcesArtifact parseResourcesArtifact( XmlPullParser parser, boolean strict )
1179 throws IOException, XmlPullParserException
1180 {
1181 String tagName = parser.getName();
1182 ResourcesArtifact resourcesArtifact = new ResourcesArtifact();
1183 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1184 {
1185 String name = parser.getAttributeName( i );
1186 String value = parser.getAttributeValue( i );
1187
1188 if ( name.indexOf( ':' ) >= 0 )
1189 {
1190
1191 }
1192 else
1193 {
1194 checkUnknownAttribute( parser, name, tagName, strict );
1195 }
1196 }
1197 java.util.Set<String> parsed = new java.util.HashSet<String>();
1198 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1199 {
1200 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) )
1201 {
1202 resourcesArtifact.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1203 }
1204 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) )
1205 {
1206 resourcesArtifact.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1207 }
1208 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
1209 {
1210 resourcesArtifact.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) );
1211 }
1212 else if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) )
1213 {
1214 resourcesArtifact.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
1215 }
1216 else
1217 {
1218 checkUnknownElement( parser, strict );
1219 }
1220 }
1221 return resourcesArtifact;
1222 }
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234 private Tag parseTag( XmlPullParser parser, boolean strict )
1235 throws IOException, XmlPullParserException
1236 {
1237 String tagName = parser.getName();
1238 Tag tag = new Tag();
1239 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1240 {
1241 String name = parser.getAttributeName( i );
1242 String value = parser.getAttributeValue( i );
1243
1244 if ( name.indexOf( ':' ) >= 0 )
1245 {
1246
1247 }
1248 else
1249 {
1250 checkUnknownAttribute( parser, name, tagName, strict );
1251 }
1252 }
1253 java.util.Set<String> parsed = new java.util.HashSet<String>();
1254 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1255 {
1256 if ( checkFieldWithDuplicate( parser, "name", null, parsed ) )
1257 {
1258 tag.setName( interpolatedTrimmed( parser.nextText(), "name" ) );
1259 }
1260 else if ( checkFieldWithDuplicate( parser, "head", null, parsed ) )
1261 {
1262 tag.setHead( interpolatedTrimmed( parser.nextText(), "head" ) );
1263 }
1264 else if ( checkFieldWithDuplicate( parser, "placement", null, parsed ) )
1265 {
1266 tag.setPlacement( interpolatedTrimmed( parser.nextText(), "placement" ) );
1267 }
1268 else
1269 {
1270 checkUnknownElement( parser, strict );
1271 }
1272 }
1273 return tag;
1274 }
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286 private Taglet parseTaglet( XmlPullParser parser, boolean strict )
1287 throws IOException, XmlPullParserException
1288 {
1289 String tagName = parser.getName();
1290 Taglet taglet = new Taglet();
1291 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1292 {
1293 String name = parser.getAttributeName( i );
1294 String value = parser.getAttributeValue( i );
1295
1296 if ( name.indexOf( ':' ) >= 0 )
1297 {
1298
1299 }
1300 else
1301 {
1302 checkUnknownAttribute( parser, name, tagName, strict );
1303 }
1304 }
1305 java.util.Set<String> parsed = new java.util.HashSet<String>();
1306 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1307 {
1308 if ( checkFieldWithDuplicate( parser, "tagletClass", null, parsed ) )
1309 {
1310 taglet.setTagletClass( interpolatedTrimmed( parser.nextText(), "tagletClass" ) );
1311 }
1312 else if ( checkFieldWithDuplicate( parser, "tagletpath", null, parsed ) )
1313 {
1314 taglet.setTagletpath( interpolatedTrimmed( parser.nextText(), "tagletpath" ) );
1315 }
1316 else if ( checkFieldWithDuplicate( parser, "tagletArtifact", null, parsed ) )
1317 {
1318 taglet.setTagletArtifact( parseTagletArtifact( parser, strict ) );
1319 }
1320 else
1321 {
1322 checkUnknownElement( parser, strict );
1323 }
1324 }
1325 return taglet;
1326 }
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338 private TagletArtifact parseTagletArtifact( XmlPullParser parser, boolean strict )
1339 throws IOException, XmlPullParserException
1340 {
1341 String tagName = parser.getName();
1342 TagletArtifact tagletArtifact = new TagletArtifact();
1343 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
1344 {
1345 String name = parser.getAttributeName( i );
1346 String value = parser.getAttributeValue( i );
1347
1348 if ( name.indexOf( ':' ) >= 0 )
1349 {
1350
1351 }
1352 else
1353 {
1354 checkUnknownAttribute( parser, name, tagName, strict );
1355 }
1356 }
1357 java.util.Set<String> parsed = new java.util.HashSet<String>();
1358 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
1359 {
1360 if ( checkFieldWithDuplicate( parser, "groupId", null, parsed ) )
1361 {
1362 tagletArtifact.setGroupId( interpolatedTrimmed( parser.nextText(), "groupId" ) );
1363 }
1364 else if ( checkFieldWithDuplicate( parser, "artifactId", null, parsed ) )
1365 {
1366 tagletArtifact.setArtifactId( interpolatedTrimmed( parser.nextText(), "artifactId" ) );
1367 }
1368 else if ( checkFieldWithDuplicate( parser, "version", null, parsed ) )
1369 {
1370 tagletArtifact.setVersion( interpolatedTrimmed( parser.nextText(), "version" ) );
1371 }
1372 else if ( checkFieldWithDuplicate( parser, "classifier", null, parsed ) )
1373 {
1374 tagletArtifact.setClassifier( interpolatedTrimmed( parser.nextText(), "classifier" ) );
1375 }
1376 else
1377 {
1378 checkUnknownElement( parser, strict );
1379 }
1380 }
1381 return tagletArtifact;
1382 }
1383
1384
1385
1386
1387
1388
1389 public void setAddDefaultEntities( boolean addDefaultEntities )
1390 {
1391 this.addDefaultEntities = addDefaultEntities;
1392 }
1393
1394 public static interface ContentTransformer
1395 {
1396
1397
1398
1399
1400
1401
1402
1403 String transform( String source, String fieldName );
1404 }
1405
1406 }