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