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