1
2
3
4
5
6 package org.apache.maven.tools.plugin.extractor.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.tools.plugin.extractor.model.Component;
17 import org.apache.maven.tools.plugin.extractor.model.LifecycleExecution;
18 import org.apache.maven.tools.plugin.extractor.model.Mojo;
19 import org.apache.maven.tools.plugin.extractor.model.Parameter;
20 import org.apache.maven.tools.plugin.extractor.model.PluginMetadata;
21 import org.codehaus.plexus.util.ReaderFactory;
22 import org.codehaus.plexus.util.xml.pull.EntityReplacementMap;
23 import org.codehaus.plexus.util.xml.pull.MXParser;
24 import org.codehaus.plexus.util.xml.pull.XmlPullParser;
25 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
26
27
28
29
30
31
32 @SuppressWarnings( "all" )
33 public class PluginMetadataXpp3Reader
34 {
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 private boolean addDefaultEntities = true;
51
52
53
54
55 public final ContentTransformer contentTransformer;
56
57
58
59
60
61
62 public PluginMetadataXpp3Reader()
63 {
64 this( new ContentTransformer()
65 {
66 public String transform( String source, String fieldName )
67 {
68 return source;
69 }
70 } );
71 }
72
73 public PluginMetadataXpp3Reader(ContentTransformer contentTransformer)
74 {
75 this.contentTransformer = contentTransformer;
76 }
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93 private boolean checkFieldWithDuplicate( XmlPullParser parser, String tagName, String alias, java.util.Set parsed )
94 throws XmlPullParserException
95 {
96 if ( !( parser.getName().equals( tagName ) || parser.getName().equals( alias ) ) )
97 {
98 return false;
99 }
100 if ( !parsed.add( tagName ) )
101 {
102 throw new XmlPullParserException( "Duplicated tag: '" + tagName + "'", parser, null );
103 }
104 return true;
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 private void checkUnknownElement( XmlPullParser parser, boolean strict )
136 throws XmlPullParserException, IOException
137 {
138 if ( strict )
139 {
140 throw new XmlPullParserException( "Unrecognised tag: '" + parser.getName() + "'", parser, null );
141 }
142
143 for ( int unrecognizedTagCount = 1; unrecognizedTagCount > 0; )
144 {
145 int eventType = parser.next();
146 if ( eventType == XmlPullParser.START_TAG )
147 {
148 unrecognizedTagCount++;
149 }
150 else if ( eventType == XmlPullParser.END_TAG )
151 {
152 unrecognizedTagCount--;
153 }
154 }
155 }
156
157
158
159
160
161
162 public boolean getAddDefaultEntities()
163 {
164 return addDefaultEntities;
165 }
166
167
168
169
170
171
172
173
174
175
176 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser )
177 throws XmlPullParserException
178 {
179 return getBooleanValue( s, attribute, parser, null );
180 }
181
182
183
184
185
186
187
188
189
190
191
192 private boolean getBooleanValue( String s, String attribute, XmlPullParser parser, String defaultValue )
193 throws XmlPullParserException
194 {
195 if ( s != null && s.length() != 0 )
196 {
197 return Boolean.valueOf( s ).booleanValue();
198 }
199 if ( defaultValue != null )
200 {
201 return Boolean.valueOf( defaultValue ).booleanValue();
202 }
203 return false;
204 }
205
206
207
208
209
210
211
212
213
214
215
216 private byte getByteValue( String s, String attribute, XmlPullParser parser, boolean strict )
217 throws XmlPullParserException
218 {
219 if ( s != null )
220 {
221 try
222 {
223 return Byte.valueOf( s ).byteValue();
224 }
225 catch ( NumberFormatException nfe )
226 {
227 if ( strict )
228 {
229 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a byte", parser, nfe );
230 }
231 }
232 }
233 return 0;
234 }
235
236
237
238
239
240
241
242
243
244
245 private char getCharacterValue( String s, String attribute, XmlPullParser parser )
246 throws XmlPullParserException
247 {
248 if ( s != null )
249 {
250 return s.charAt( 0 );
251 }
252 return 0;
253 }
254
255
256
257
258
259
260
261
262
263
264 private java.util.Date getDateValue( String s, String attribute, XmlPullParser parser )
265 throws XmlPullParserException
266 {
267 return getDateValue( s, attribute, null, parser );
268 }
269
270
271
272
273
274
275
276
277
278
279
280 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XmlPullParser parser )
281 throws XmlPullParserException
282 {
283 if ( s != null )
284 {
285 String effectiveDateFormat = dateFormat;
286 if ( dateFormat == null )
287 {
288 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
289 }
290 if ( "long".equals( effectiveDateFormat ) )
291 {
292 try
293 {
294 return new java.util.Date( Long.parseLong( s ) );
295 }
296 catch ( NumberFormatException e )
297 {
298 throw new XmlPullParserException( e.getMessage(), parser, e );
299 }
300 }
301 else
302 {
303 try
304 {
305 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
306 return dateParser.parse( s );
307 }
308 catch ( java.text.ParseException e )
309 {
310 throw new XmlPullParserException( e.getMessage(), parser, e );
311 }
312 }
313 }
314 return null;
315 }
316
317
318
319
320
321
322
323
324
325
326
327 private double getDoubleValue( String s, String attribute, XmlPullParser parser, boolean strict )
328 throws XmlPullParserException
329 {
330 if ( s != null )
331 {
332 try
333 {
334 return Double.valueOf( s ).doubleValue();
335 }
336 catch ( NumberFormatException nfe )
337 {
338 if ( strict )
339 {
340 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
341 }
342 }
343 }
344 return 0;
345 }
346
347
348
349
350
351
352
353
354
355
356
357 private float getFloatValue( String s, String attribute, XmlPullParser parser, boolean strict )
358 throws XmlPullParserException
359 {
360 if ( s != null )
361 {
362 try
363 {
364 return Float.valueOf( s ).floatValue();
365 }
366 catch ( NumberFormatException nfe )
367 {
368 if ( strict )
369 {
370 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a floating point number", parser, nfe );
371 }
372 }
373 }
374 return 0;
375 }
376
377
378
379
380
381
382
383
384
385
386
387 private int getIntegerValue( String s, String attribute, XmlPullParser parser, boolean strict )
388 throws XmlPullParserException
389 {
390 if ( s != null )
391 {
392 try
393 {
394 return Integer.valueOf( s ).intValue();
395 }
396 catch ( NumberFormatException nfe )
397 {
398 if ( strict )
399 {
400 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be an integer", parser, nfe );
401 }
402 }
403 }
404 return 0;
405 }
406
407
408
409
410
411
412
413
414
415
416
417 private long getLongValue( String s, String attribute, XmlPullParser parser, boolean strict )
418 throws XmlPullParserException
419 {
420 if ( s != null )
421 {
422 try
423 {
424 return Long.valueOf( s ).longValue();
425 }
426 catch ( NumberFormatException nfe )
427 {
428 if ( strict )
429 {
430 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a long integer", parser, nfe );
431 }
432 }
433 }
434 return 0;
435 }
436
437
438
439
440
441
442
443
444
445
446
447 private String getRequiredAttributeValue( String s, String attribute, XmlPullParser parser, boolean strict )
448 throws XmlPullParserException
449 {
450 if ( s == null )
451 {
452 if ( strict )
453 {
454 throw new XmlPullParserException( "Missing required value for attribute '" + attribute + "'", parser, null );
455 }
456 }
457 return s;
458 }
459
460
461
462
463
464
465
466
467
468
469
470 private short getShortValue( String s, String attribute, XmlPullParser parser, boolean strict )
471 throws XmlPullParserException
472 {
473 if ( s != null )
474 {
475 try
476 {
477 return Short.valueOf( s ).shortValue();
478 }
479 catch ( NumberFormatException nfe )
480 {
481 if ( strict )
482 {
483 throw new XmlPullParserException( "Unable to parse element '" + attribute + "', must be a short integer", parser, nfe );
484 }
485 }
486 }
487 return 0;
488 }
489
490
491
492
493
494
495
496 private String getTrimmedValue( String s )
497 {
498 if ( s != null )
499 {
500 s = s.trim();
501 }
502 return s;
503 }
504
505
506
507
508
509
510
511
512 private String interpolatedTrimmed( String value, String context )
513 {
514 return getTrimmedValue( contentTransformer.transform( value, context ) );
515 }
516
517
518
519
520
521
522
523
524
525 private int nextTag( XmlPullParser parser )
526 throws IOException, XmlPullParserException
527 {
528 int eventType = parser.next();
529 if ( eventType == XmlPullParser.TEXT )
530 {
531 eventType = parser.next();
532 }
533 if ( eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG )
534 {
535 throw new XmlPullParserException( "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null );
536 }
537 return eventType;
538 }
539
540
541
542
543
544
545
546
547
548
549 public PluginMetadata read( Reader reader, boolean strict )
550 throws IOException, XmlPullParserException
551 {
552 XmlPullParser parser = addDefaultEntities ? new MXParser(EntityReplacementMap.defaultEntityReplacementMap) : new MXParser( );
553
554 parser.setInput( reader );
555
556
557 return read( parser, strict );
558 }
559
560
561
562
563
564
565
566
567
568 public PluginMetadata read( Reader reader )
569 throws IOException, XmlPullParserException
570 {
571 return read( reader, true );
572 }
573
574
575
576
577
578
579
580
581
582
583 public PluginMetadata 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 public PluginMetadata read( InputStream in )
598 throws IOException, XmlPullParserException
599 {
600 return read( ReaderFactory.newXmlReader( in ) );
601 }
602
603
604
605
606
607
608
609
610
611
612 private Component parseComponent( XmlPullParser parser, boolean strict )
613 throws IOException, XmlPullParserException
614 {
615 String tagName = parser.getName();
616 Component component = new Component();
617 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
618 {
619 String name = parser.getAttributeName( i );
620 String value = parser.getAttributeValue( i );
621
622 if ( name.indexOf( ':' ) >= 0 )
623 {
624
625 }
626 else
627 {
628 checkUnknownAttribute( parser, name, tagName, strict );
629 }
630 }
631 java.util.Set parsed = new java.util.HashSet();
632 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
633 {
634 if ( checkFieldWithDuplicate( parser, "role", null, parsed ) )
635 {
636 component.setRole( interpolatedTrimmed( parser.nextText(), "role" ) );
637 }
638 else if ( checkFieldWithDuplicate( parser, "hint", null, parsed ) )
639 {
640 component.setHint( interpolatedTrimmed( parser.nextText(), "hint" ) );
641 }
642 else
643 {
644 checkUnknownElement( parser, strict );
645 }
646 }
647 return component;
648 }
649
650
651
652
653
654
655
656
657
658
659 private LifecycleExecution parseLifecycleExecution( XmlPullParser parser, boolean strict )
660 throws IOException, XmlPullParserException
661 {
662 String tagName = parser.getName();
663 LifecycleExecution lifecycleExecution = new LifecycleExecution();
664 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
665 {
666 String name = parser.getAttributeName( i );
667 String value = parser.getAttributeValue( i );
668
669 if ( name.indexOf( ':' ) >= 0 )
670 {
671
672 }
673 else
674 {
675 checkUnknownAttribute( parser, name, tagName, strict );
676 }
677 }
678 java.util.Set parsed = new java.util.HashSet();
679 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
680 {
681 if ( checkFieldWithDuplicate( parser, "lifecycle", null, parsed ) )
682 {
683 lifecycleExecution.setLifecycle( interpolatedTrimmed( parser.nextText(), "lifecycle" ) );
684 }
685 else if ( checkFieldWithDuplicate( parser, "phase", null, parsed ) )
686 {
687 lifecycleExecution.setPhase( interpolatedTrimmed( parser.nextText(), "phase" ) );
688 }
689 else if ( checkFieldWithDuplicate( parser, "goal", null, parsed ) )
690 {
691 lifecycleExecution.setGoal( interpolatedTrimmed( parser.nextText(), "goal" ) );
692 }
693 else
694 {
695 checkUnknownElement( parser, strict );
696 }
697 }
698 return lifecycleExecution;
699 }
700
701
702
703
704
705
706
707
708
709
710 private Mojo parseMojo( XmlPullParser parser, boolean strict )
711 throws IOException, XmlPullParserException
712 {
713 String tagName = parser.getName();
714 Mojo mojo = new Mojo();
715 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
716 {
717 String name = parser.getAttributeName( i );
718 String value = parser.getAttributeValue( i );
719
720 if ( name.indexOf( ':' ) >= 0 )
721 {
722
723 }
724 else
725 {
726 checkUnknownAttribute( parser, name, tagName, strict );
727 }
728 }
729 java.util.Set parsed = new java.util.HashSet();
730 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
731 {
732 if ( checkFieldWithDuplicate( parser, "goal", null, parsed ) )
733 {
734 mojo.setGoal( interpolatedTrimmed( parser.nextText(), "goal" ) );
735 }
736 else if ( checkFieldWithDuplicate( parser, "phase", null, parsed ) )
737 {
738 mojo.setPhase( interpolatedTrimmed( parser.nextText(), "phase" ) );
739 }
740 else if ( checkFieldWithDuplicate( parser, "aggregator", null, parsed ) )
741 {
742 mojo.setAggregator( getBooleanValue( interpolatedTrimmed( parser.nextText(), "aggregator" ), "aggregator", parser, "false" ) );
743 }
744 else if ( checkFieldWithDuplicate( parser, "requiresDependencyResolution", null, parsed ) )
745 {
746 mojo.setRequiresDependencyResolution( interpolatedTrimmed( parser.nextText(), "requiresDependencyResolution" ) );
747 }
748 else if ( checkFieldWithDuplicate( parser, "requiresProject", null, parsed ) )
749 {
750 mojo.setRequiresProject( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresProject" ), "requiresProject", parser, "false" ) );
751 }
752 else if ( checkFieldWithDuplicate( parser, "requiresReports", null, parsed ) )
753 {
754 mojo.setRequiresReports( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresReports" ), "requiresReports", parser, "false" ) );
755 }
756 else if ( checkFieldWithDuplicate( parser, "requiresOnline", null, parsed ) )
757 {
758 mojo.setRequiresOnline( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresOnline" ), "requiresOnline", parser, "false" ) );
759 }
760 else if ( checkFieldWithDuplicate( parser, "inheritByDefault", null, parsed ) )
761 {
762 mojo.setInheritByDefault( getBooleanValue( interpolatedTrimmed( parser.nextText(), "inheritByDefault" ), "inheritByDefault", parser, "false" ) );
763 }
764 else if ( checkFieldWithDuplicate( parser, "requiresDirectInvocation", null, parsed ) )
765 {
766 mojo.setRequiresDirectInvocation( getBooleanValue( interpolatedTrimmed( parser.nextText(), "requiresDirectInvocation" ), "requiresDirectInvocation", parser, "false" ) );
767 }
768 else if ( checkFieldWithDuplicate( parser, "execution", null, parsed ) )
769 {
770 mojo.setExecution( parseLifecycleExecution( parser, strict ) );
771 }
772 else if ( checkFieldWithDuplicate( parser, "components", null, parsed ) )
773 {
774 java.util.List<Component> components = new java.util.ArrayList<Component>();
775 mojo.setComponents( components );
776 while ( parser.nextTag() == XmlPullParser.START_TAG )
777 {
778 if ( "component".equals( parser.getName() ) )
779 {
780 components.add( parseComponent( parser, strict ) );
781 }
782 else
783 {
784 checkUnknownElement( parser, strict );
785 }
786 }
787 }
788 else if ( checkFieldWithDuplicate( parser, "parameters", null, parsed ) )
789 {
790 java.util.List<Parameter> parameters = new java.util.ArrayList<Parameter>();
791 mojo.setParameters( parameters );
792 while ( parser.nextTag() == XmlPullParser.START_TAG )
793 {
794 if ( "parameter".equals( parser.getName() ) )
795 {
796 parameters.add( parseParameter( parser, strict ) );
797 }
798 else
799 {
800 checkUnknownElement( parser, strict );
801 }
802 }
803 }
804 else if ( checkFieldWithDuplicate( parser, "description", null, parsed ) )
805 {
806 mojo.setDescription( interpolatedTrimmed( parser.nextText(), "description" ) );
807 }
808 else if ( checkFieldWithDuplicate( parser, "deprecated", null, parsed ) )
809 {
810 mojo.setDeprecation( interpolatedTrimmed( parser.nextText(), "deprecated" ) );
811 }
812 else if ( checkFieldWithDuplicate( parser, "since", null, parsed ) )
813 {
814 mojo.setSince( interpolatedTrimmed( parser.nextText(), "since" ) );
815 }
816 else if ( checkFieldWithDuplicate( parser, "call", null, parsed ) )
817 {
818 mojo.setCall( interpolatedTrimmed( parser.nextText(), "call" ) );
819 }
820 else
821 {
822 checkUnknownElement( parser, strict );
823 }
824 }
825 return mojo;
826 }
827
828
829
830
831
832
833
834
835
836
837 private Parameter parseParameter( XmlPullParser parser, boolean strict )
838 throws IOException, XmlPullParserException
839 {
840 String tagName = parser.getName();
841 Parameter parameter = new Parameter();
842 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
843 {
844 String name = parser.getAttributeName( i );
845 String value = parser.getAttributeValue( i );
846
847 if ( name.indexOf( ':' ) >= 0 )
848 {
849
850 }
851 else
852 {
853 checkUnknownAttribute( parser, name, tagName, strict );
854 }
855 }
856 java.util.Set parsed = new java.util.HashSet();
857 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
858 {
859 if ( checkFieldWithDuplicate( parser, "name", null, parsed ) )
860 {
861 parameter.setName( interpolatedTrimmed( parser.nextText(), "name" ) );
862 }
863 else if ( checkFieldWithDuplicate( parser, "alias", null, parsed ) )
864 {
865 parameter.setAlias( interpolatedTrimmed( parser.nextText(), "alias" ) );
866 }
867 else if ( checkFieldWithDuplicate( parser, "property", null, parsed ) )
868 {
869 parameter.setProperty( interpolatedTrimmed( parser.nextText(), "property" ) );
870 }
871 else if ( checkFieldWithDuplicate( parser, "required", null, parsed ) )
872 {
873 parameter.setRequired( getBooleanValue( interpolatedTrimmed( parser.nextText(), "required" ), "required", parser, "false" ) );
874 }
875 else if ( checkFieldWithDuplicate( parser, "readonly", null, parsed ) )
876 {
877 parameter.setReadonly( getBooleanValue( interpolatedTrimmed( parser.nextText(), "readonly" ), "readonly", parser, "false" ) );
878 }
879 else if ( checkFieldWithDuplicate( parser, "expression", null, parsed ) )
880 {
881 parameter.setExpression( interpolatedTrimmed( parser.nextText(), "expression" ) );
882 }
883 else if ( checkFieldWithDuplicate( parser, "defaultValue", null, parsed ) )
884 {
885 parameter.setDefaultValue( interpolatedTrimmed( parser.nextText(), "defaultValue" ) );
886 }
887 else if ( checkFieldWithDuplicate( parser, "type", null, parsed ) )
888 {
889 parameter.setType( interpolatedTrimmed( parser.nextText(), "type" ) );
890 }
891 else if ( checkFieldWithDuplicate( parser, "description", null, parsed ) )
892 {
893 parameter.setDescription( interpolatedTrimmed( parser.nextText(), "description" ) );
894 }
895 else if ( checkFieldWithDuplicate( parser, "deprecated", null, parsed ) )
896 {
897 parameter.setDeprecation( interpolatedTrimmed( parser.nextText(), "deprecated" ) );
898 }
899 else if ( checkFieldWithDuplicate( parser, "since", null, parsed ) )
900 {
901 parameter.setSince( interpolatedTrimmed( parser.nextText(), "since" ) );
902 }
903 else
904 {
905 checkUnknownElement( parser, strict );
906 }
907 }
908 return parameter;
909 }
910
911
912
913
914
915
916
917
918
919
920 private PluginMetadata parsePluginMetadata( XmlPullParser parser, boolean strict )
921 throws IOException, XmlPullParserException
922 {
923 String tagName = parser.getName();
924 PluginMetadata pluginMetadata = new PluginMetadata();
925 for ( int i = parser.getAttributeCount() - 1; i >= 0; i-- )
926 {
927 String name = parser.getAttributeName( i );
928 String value = parser.getAttributeValue( i );
929
930 if ( name.indexOf( ':' ) >= 0 )
931 {
932
933 }
934 else if ( "xmlns".equals( name ) )
935 {
936
937 }
938 else
939 {
940 checkUnknownAttribute( parser, name, tagName, strict );
941 }
942 }
943 java.util.Set parsed = new java.util.HashSet();
944 while ( ( strict ? parser.nextTag() : nextTag( parser ) ) == XmlPullParser.START_TAG )
945 {
946 if ( checkFieldWithDuplicate( parser, "mojos", null, parsed ) )
947 {
948 java.util.List<Mojo> mojos = new java.util.ArrayList<Mojo>();
949 pluginMetadata.setMojos( mojos );
950 while ( parser.nextTag() == XmlPullParser.START_TAG )
951 {
952 if ( "mojo".equals( parser.getName() ) )
953 {
954 mojos.add( parseMojo( parser, strict ) );
955 }
956 else
957 {
958 checkUnknownElement( parser, strict );
959 }
960 }
961 }
962 else
963 {
964 checkUnknownElement( parser, strict );
965 }
966 }
967 return pluginMetadata;
968 }
969
970
971
972
973
974
975
976
977
978
979 private PluginMetadata read( XmlPullParser parser, boolean strict )
980 throws IOException, XmlPullParserException
981 {
982 PluginMetadata pluginMetadata = null;
983 int eventType = parser.getEventType();
984 boolean parsed = false;
985 while ( eventType != XmlPullParser.END_DOCUMENT )
986 {
987 if ( eventType == XmlPullParser.START_TAG )
988 {
989 if ( strict && ! "pluginMetadata".equals( parser.getName() ) )
990 {
991 throw new XmlPullParserException( "Expected root element 'pluginMetadata' but found '" + parser.getName() + "'", parser, null );
992 }
993 else if ( parsed )
994 {
995
996 throw new XmlPullParserException( "Duplicated tag: 'pluginMetadata'", parser, null );
997 }
998 pluginMetadata = parsePluginMetadata( parser, strict );
999 pluginMetadata.setModelEncoding( parser.getInputEncoding() );
1000 parsed = true;
1001 }
1002 eventType = parser.next();
1003 }
1004 if ( parsed )
1005 {
1006 return pluginMetadata;
1007 }
1008 throw new XmlPullParserException( "Expected root element 'pluginMetadata' but found no element at all: invalid XML document", parser, null );
1009 }
1010
1011
1012
1013
1014
1015
1016 public void setAddDefaultEntities( boolean addDefaultEntities )
1017 {
1018 this.addDefaultEntities = addDefaultEntities;
1019 }
1020
1021 public static interface ContentTransformer
1022 {
1023
1024
1025
1026
1027
1028
1029
1030 String transform( String source, String fieldName );
1031 }
1032
1033 }