This project has retired. For details please refer to its
Attic page.
RbacJdoModelStaxReader xref
1
2
3
4
5
6 package org.apache.archiva.redback.rbac.jdo.io.stax;
7
8
9
10
11
12 import java.io.ByteArrayInputStream;
13 import java.io.FileInputStream;
14 import java.io.IOException;
15 import java.io.InputStream;
16 import java.io.InputStreamReader;
17 import java.io.Reader;
18 import java.io.StringReader;
19 import java.io.StringWriter;
20 import java.text.DateFormat;
21 import java.text.ParsePosition;
22 import java.util.Locale;
23 import java.util.regex.Matcher;
24 import java.util.regex.Pattern;
25 import javax.xml.stream.*;
26 import org.apache.archiva.redback.rbac.jdo.JdoOperation;
27 import org.apache.archiva.redback.rbac.jdo.JdoPermission;
28 import org.apache.archiva.redback.rbac.jdo.JdoResource;
29 import org.apache.archiva.redback.rbac.jdo.JdoRole;
30 import org.apache.archiva.redback.rbac.jdo.JdoUserAssignment;
31 import org.apache.archiva.redback.rbac.jdo.RbacDatabase;
32
33
34
35
36
37
38 public class RbacJdoModelStaxReader
39 {
40
41
42
43
44
45
46
47
48 private java.util.Map jdoPermissionReferences;
49
50
51
52
53 private java.util.Map jdoPermissionInstances;
54
55
56
57
58 private java.util.Map jdoOperationReferences;
59
60
61
62
63 private java.util.Map jdoResourceReferences;
64
65
66
67
68 private java.util.Map jdoOperationInstances;
69
70
71
72
73 private java.util.Map jdoResourceInstances;
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89 public RbacDatabase read( Reader reader, boolean strict )
90 throws IOException, XMLStreamException
91 {
92 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );
93
94 return read( xmlStreamReader, strict );
95 }
96
97
98
99
100
101
102
103
104
105 public RbacDatabase read( Reader reader )
106 throws IOException, XMLStreamException
107 {
108 return read( reader, true );
109 }
110
111
112
113
114
115
116
117
118
119
120 public RbacDatabase read( InputStream stream, boolean strict )
121 throws IOException, XMLStreamException
122 {
123 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( stream );
124
125 return read( xmlStreamReader, strict );
126 }
127
128
129
130
131
132
133
134
135
136 public RbacDatabase read( InputStream stream )
137 throws IOException, XMLStreamException
138 {
139 return read( stream, true );
140 }
141
142
143
144
145
146
147
148
149
150
151 public RbacDatabase read( String filePath, boolean strict )
152 throws IOException, XMLStreamException
153 {
154 java.io.File file = new java.io.File( filePath );
155 XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( file.toURI().toURL().toExternalForm(), new FileInputStream( file ) );
156
157 return read( xmlStreamReader, strict );
158 }
159
160
161
162
163
164
165
166
167
168 public RbacDatabase read( String filePath )
169 throws IOException, XMLStreamException
170 {
171 return read( filePath, true );
172 }
173
174
175
176
177
178
179
180
181
182
183
184 private boolean checkFieldWithDuplicate( XMLStreamReader xmlStreamReader, String tagName, String alias, java.util.Set parsed )
185 throws XMLStreamException
186 {
187 if ( !( xmlStreamReader.getLocalName().equals( tagName ) || xmlStreamReader.getLocalName().equals( alias ) ) )
188 {
189 return false;
190 }
191 if ( !parsed.add( tagName ) )
192 {
193 throw new XMLStreamException( "Duplicated tag: '" + tagName + "'", xmlStreamReader.getLocation() );
194 }
195 return true;
196 }
197
198
199
200
201
202
203
204
205 private void checkUnknownElement( XMLStreamReader xmlStreamReader, boolean strict )
206 throws XMLStreamException
207 {
208 if ( strict )
209 {
210 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
211 }
212 int unrecognizedTagCount = 1;
213 while( unrecognizedTagCount != 0 )
214 {
215 xmlStreamReader.next();
216 if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
217 {
218 unrecognizedTagCount++;
219 }
220 else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
221 {
222 unrecognizedTagCount--;
223 }
224 }
225 }
226
227
228
229
230
231
232
233
234
235
236 private boolean getBooleanValue( String s, String attribute, XMLStreamReader xmlStreamReader )
237 throws XMLStreamException
238 {
239 if ( s != null )
240 {
241 return Boolean.valueOf( s ).booleanValue();
242 }
243 return false;
244 }
245
246
247
248
249
250
251
252
253
254
255
256 private byte getByteValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
257 throws XMLStreamException
258 {
259 if ( s != null )
260 {
261 try
262 {
263 return Byte.valueOf( s ).byteValue();
264 }
265 catch ( NumberFormatException nfe )
266 {
267 if ( strict )
268 {
269 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a byte but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
270 }
271 }
272 }
273 return 0;
274 }
275
276
277
278
279
280
281
282
283
284
285 private char getCharacterValue( String s, String attribute, XMLStreamReader xmlStreamReader )
286 throws XMLStreamException
287 {
288 if ( s != null )
289 {
290 return s.charAt( 0 );
291 }
292 return 0;
293 }
294
295
296
297
298
299
300
301
302
303
304
305 private java.util.Date getDateValue( String s, String attribute, String dateFormat, XMLStreamReader xmlStreamReader )
306 throws XMLStreamException
307 {
308 if ( s != null )
309 {
310 String effectiveDateFormat = dateFormat;
311 if ( dateFormat == null )
312 {
313 effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
314 }
315 if ( "long".equals( effectiveDateFormat ) )
316 {
317 try
318 {
319 return new java.util.Date( Long.parseLong( s ) );
320 }
321 catch ( NumberFormatException e )
322 {
323 throw new XMLStreamException( e.getMessage(), xmlStreamReader.getLocation(), e );
324 }
325 }
326 else
327 {
328 try
329 {
330 DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
331 return dateParser.parse( s );
332 }
333 catch ( java.text.ParseException e )
334 {
335 throw new XMLStreamException( e.getMessage(), xmlStreamReader.getLocation(), e );
336 }
337 }
338 }
339 return null;
340 }
341
342
343
344
345
346
347
348
349 private String getDefaultValue( String s, String v )
350 {
351 if ( s == null )
352 {
353 s = v;
354 }
355 return s;
356 }
357
358
359
360
361
362
363
364
365
366
367
368 private double getDoubleValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
369 throws XMLStreamException
370 {
371 if ( s != null )
372 {
373 try
374 {
375 return Double.valueOf( s ).doubleValue();
376 }
377 catch ( NumberFormatException nfe )
378 {
379 if ( strict )
380 {
381 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
382 }
383 }
384 }
385 return 0;
386 }
387
388
389
390
391
392
393
394
395
396
397
398 private float getFloatValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
399 throws XMLStreamException
400 {
401 if ( s != null )
402 {
403 try
404 {
405 return Float.valueOf( s ).floatValue();
406 }
407 catch ( NumberFormatException nfe )
408 {
409 if ( strict )
410 {
411 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
412 }
413 }
414 }
415 return 0;
416 }
417
418
419
420
421
422
423
424
425
426
427
428 private int getIntegerValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
429 throws XMLStreamException
430 {
431 if ( s != null )
432 {
433 try
434 {
435 return Integer.valueOf( s ).intValue();
436 }
437 catch ( NumberFormatException nfe )
438 {
439 if ( strict )
440 {
441 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be an integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
442 }
443 }
444 }
445 return 0;
446 }
447
448
449
450
451
452
453
454
455
456
457
458 private long getLongValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
459 throws XMLStreamException
460 {
461 if ( s != null )
462 {
463 try
464 {
465 return Long.valueOf( s ).longValue();
466 }
467 catch ( NumberFormatException nfe )
468 {
469 if ( strict )
470 {
471 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a long integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
472 }
473 }
474 }
475 return 0;
476 }
477
478
479
480
481
482
483
484
485
486
487
488 private String getRequiredAttributeValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
489 throws XMLStreamException
490 {
491 if ( s == null )
492 {
493 if ( strict )
494 {
495 throw new XMLStreamException( "Missing required value for attribute '" + attribute + "'", xmlStreamReader.getLocation() );
496 }
497 }
498 return s;
499 }
500
501
502
503
504
505
506
507
508
509
510
511 private short getShortValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
512 throws XMLStreamException
513 {
514 if ( s != null )
515 {
516 try
517 {
518 return Short.valueOf( s ).shortValue();
519 }
520 catch ( NumberFormatException nfe )
521 {
522 if ( strict )
523 {
524 throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a short integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
525 }
526 }
527 }
528 return 0;
529 }
530
531
532
533
534
535
536
537 private String getTrimmedValue( String s )
538 {
539 if ( s != null )
540 {
541 s = s.trim();
542 }
543 return s;
544 }
545
546
547
548
549
550
551
552
553 private int nextTag( XMLStreamReader xmlStreamReader )
554 throws XMLStreamException
555 {
556 while ( true )
557 {
558 int eventType = xmlStreamReader.next();
559 switch ( eventType )
560 {
561 case XMLStreamConstants.CHARACTERS:
562 case XMLStreamConstants.CDATA:
563 case XMLStreamConstants.SPACE:
564 case XMLStreamConstants.PROCESSING_INSTRUCTION:
565 case XMLStreamConstants.COMMENT:
566 break;
567 case XMLStreamConstants.START_ELEMENT:
568 case XMLStreamConstants.END_ELEMENT:
569 return eventType;
570 default:
571 throw new XMLStreamException( "expected start or end tag", xmlStreamReader.getLocation() );
572 }
573 }
574 }
575
576
577
578
579
580
581
582
583
584
585 private JdoOperation parseJdoOperation( XMLStreamReader xmlStreamReader, boolean strict )
586 throws IOException, XMLStreamException
587 {
588 JdoOperation jdoOperation = new JdoOperation();
589 java.util.Set parsed = new java.util.HashSet();
590 if ( jdoOperationInstances == null )
591 {
592 jdoOperationInstances = new java.util.HashMap();
593 }
594 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
595 if ( v != null )
596 {
597 jdoOperationInstances.put( v, jdoOperation );
598 }
599 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
600 {
601 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
602 {
603 jdoOperation.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
604 }
605 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
606 {
607 jdoOperation.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
608 }
609 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
610 {
611 jdoOperation.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
612 }
613 else if ( checkFieldWithDuplicate( xmlStreamReader, "resourceRequired", null, parsed ) )
614 {
615 jdoOperation.setResourceRequired( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "resourceRequired", xmlStreamReader ) );
616 }
617 else
618 {
619 checkUnknownElement( xmlStreamReader, strict );
620 }
621 }
622 jdoOperationInstances.put( jdoOperation.getName(), jdoOperation );
623 return jdoOperation;
624 }
625
626
627
628
629
630
631
632
633
634
635 private JdoPermission parseJdoPermission( XMLStreamReader xmlStreamReader, boolean strict )
636 throws IOException, XMLStreamException
637 {
638 JdoPermission jdoPermission = new JdoPermission();
639 java.util.Set parsed = new java.util.HashSet();
640 if ( jdoPermissionInstances == null )
641 {
642 jdoPermissionInstances = new java.util.HashMap();
643 }
644 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
645 if ( v != null )
646 {
647 jdoPermissionInstances.put( v, jdoPermission );
648 }
649 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
650 {
651 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
652 {
653 jdoPermission.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
654 }
655 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
656 {
657 jdoPermission.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
658 }
659 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
660 {
661 jdoPermission.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
662 }
663 else if ( checkFieldWithDuplicate( xmlStreamReader, "operation", null, parsed ) )
664 {
665 String value = xmlStreamReader.getAttributeValue( null, "name" );
666 if ( value != null )
667 {
668
669 if ( jdoOperationReferences == null )
670 {
671 jdoOperationReferences = new java.util.HashMap();
672 }
673 java.util.Map refs = (java.util.Map) jdoOperationReferences.get( jdoPermission );
674 if ( refs == null )
675 {
676 refs = new java.util.HashMap();
677 jdoOperationReferences.put( jdoPermission, refs );
678 }
679 refs.put( "operation", value );
680 }
681 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
682 {
683 xmlStreamReader.next();
684 }
685 }
686 else if ( checkFieldWithDuplicate( xmlStreamReader, "resource", null, parsed ) )
687 {
688 String value = xmlStreamReader.getAttributeValue( null, "identifier" );
689 if ( value != null )
690 {
691
692 if ( jdoResourceReferences == null )
693 {
694 jdoResourceReferences = new java.util.HashMap();
695 }
696 java.util.Map refs = (java.util.Map) jdoResourceReferences.get( jdoPermission );
697 if ( refs == null )
698 {
699 refs = new java.util.HashMap();
700 jdoResourceReferences.put( jdoPermission, refs );
701 }
702 refs.put( "resource", value );
703 }
704 while ( xmlStreamReader.getEventType() != XMLStreamConstants.END_ELEMENT )
705 {
706 xmlStreamReader.next();
707 }
708 }
709 else
710 {
711 checkUnknownElement( xmlStreamReader, strict );
712 }
713 }
714 jdoPermissionInstances.put( jdoPermission.getName(), jdoPermission );
715 return jdoPermission;
716 }
717
718
719
720
721
722
723
724
725
726
727 private JdoResource parseJdoResource( XMLStreamReader xmlStreamReader, boolean strict )
728 throws IOException, XMLStreamException
729 {
730 JdoResource jdoResource = new JdoResource();
731 java.util.Set parsed = new java.util.HashSet();
732 if ( jdoResourceInstances == null )
733 {
734 jdoResourceInstances = new java.util.HashMap();
735 }
736 String v = xmlStreamReader.getAttributeValue( null, "modello.id" );
737 if ( v != null )
738 {
739 jdoResourceInstances.put( v, jdoResource );
740 }
741 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
742 {
743 if ( checkFieldWithDuplicate( xmlStreamReader, "identifier", null, parsed ) )
744 {
745 jdoResource.setIdentifier( getTrimmedValue( xmlStreamReader.getElementText() ) );
746 }
747 else if ( checkFieldWithDuplicate( xmlStreamReader, "pattern", null, parsed ) )
748 {
749 jdoResource.setPattern( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "pattern", xmlStreamReader ) );
750 }
751 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
752 {
753 jdoResource.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
754 }
755 else
756 {
757 checkUnknownElement( xmlStreamReader, strict );
758 }
759 }
760 jdoResourceInstances.put( jdoResource.getIdentifier(), jdoResource );
761 return jdoResource;
762 }
763
764
765
766
767
768
769
770
771
772
773 private JdoRole parseJdoRole( XMLStreamReader xmlStreamReader, boolean strict )
774 throws IOException, XMLStreamException
775 {
776 JdoRole jdoRole = new JdoRole();
777 java.util.Set parsed = new java.util.HashSet();
778 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
779 {
780 if ( checkFieldWithDuplicate( xmlStreamReader, "name", null, parsed ) )
781 {
782 jdoRole.setName( getTrimmedValue( xmlStreamReader.getElementText() ) );
783 }
784 else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
785 {
786 jdoRole.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
787 }
788 else if ( checkFieldWithDuplicate( xmlStreamReader, "assignable", null, parsed ) )
789 {
790 jdoRole.setAssignable( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "assignable", xmlStreamReader ) );
791 }
792 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
793 {
794 jdoRole.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
795 }
796 else if ( checkFieldWithDuplicate( xmlStreamReader, "childRoleNames", null, parsed ) )
797 {
798 java.util.List childRoleNames = new java.util.ArrayList
799 jdoRole.setChildRoleNames( childRoleNames );
800 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
801 {
802 if ( "childRoleName".equals( xmlStreamReader.getLocalName() ) )
803 {
804 childRoleNames.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
805 }
806 else
807 {
808 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
809 }
810 }
811 }
812 else if ( checkFieldWithDuplicate( xmlStreamReader, "permissions", null, parsed ) )
813 {
814 java.util.List permissions = new java.util.ArrayList
815 jdoRole.setPermissions( permissions );
816 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
817 {
818 if ( "permission".equals( xmlStreamReader.getLocalName() ) )
819 {
820 String value = xmlStreamReader.getAttributeValue( null, "name" );
821 if ( value != null )
822 {
823
824 if ( jdoPermissionReferences == null )
825 {
826 jdoPermissionReferences = new java.util.HashMap();
827 }
828 java.util.Map refs = (java.util.Map) jdoPermissionReferences.get( jdoRole );
829 if ( refs == null )
830 {
831 refs = new java.util.HashMap();
832 jdoPermissionReferences.put( jdoRole, refs );
833 }
834 refs.put( "permissions." + permissions.size(), value );
835 }
836 jdoRole.addPermission( parseJdoPermission( xmlStreamReader, strict ) );
837 }
838 else
839 {
840 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
841 }
842 }
843 }
844 else
845 {
846 checkUnknownElement( xmlStreamReader, strict );
847 }
848 }
849 return jdoRole;
850 }
851
852
853
854
855
856
857
858
859
860
861 private JdoUserAssignment parseJdoUserAssignment( XMLStreamReader xmlStreamReader, boolean strict )
862 throws IOException, XMLStreamException
863 {
864 JdoUserAssignment jdoUserAssignment = new JdoUserAssignment();
865 java.util.Set parsed = new java.util.HashSet();
866 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
867 {
868 if ( checkFieldWithDuplicate( xmlStreamReader, "principal", null, parsed ) )
869 {
870 jdoUserAssignment.setPrincipal( getTrimmedValue( xmlStreamReader.getElementText() ) );
871 }
872 else if ( checkFieldWithDuplicate( xmlStreamReader, "timestamp", null, parsed ) )
873 {
874 String dateFormat = "long";
875 jdoUserAssignment.setTimestamp( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "timestamp", dateFormat, xmlStreamReader ) );
876 }
877 else if ( checkFieldWithDuplicate( xmlStreamReader, "permanent", null, parsed ) )
878 {
879 jdoUserAssignment.setPermanent( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "permanent", xmlStreamReader ) );
880 }
881 else if ( checkFieldWithDuplicate( xmlStreamReader, "roleNames", null, parsed ) )
882 {
883 java.util.List roleNames = new java.util.ArrayList
884 jdoUserAssignment.setRoleNames( roleNames );
885 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
886 {
887 if ( "roleName".equals( xmlStreamReader.getLocalName() ) )
888 {
889 roleNames.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
890 }
891 else
892 {
893 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
894 }
895 }
896 }
897 else
898 {
899 checkUnknownElement( xmlStreamReader, strict );
900 }
901 }
902 return jdoUserAssignment;
903 }
904
905
906
907
908
909
910
911
912
913
914 private RbacDatabase parseRbacDatabase( XMLStreamReader xmlStreamReader, boolean strict )
915 throws IOException, XMLStreamException
916 {
917 RbacDatabase rbacDatabase = new RbacDatabase();
918 java.util.Set parsed = new java.util.HashSet();
919 while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
920 {
921 if ( checkFieldWithDuplicate( xmlStreamReader, "roles", null, parsed ) )
922 {
923 java.util.List roles = new java.util.ArrayList
924 rbacDatabase.setRoles( roles );
925 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
926 {
927 if ( "role".equals( xmlStreamReader.getLocalName() ) )
928 {
929 rbacDatabase.addRole( parseJdoRole( xmlStreamReader, strict ) );
930 }
931 else
932 {
933 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
934 }
935 }
936 }
937 else if ( checkFieldWithDuplicate( xmlStreamReader, "permissions", null, parsed ) )
938 {
939 java.util.List permissions = new java.util.ArrayList
940 rbacDatabase.setPermissions( permissions );
941 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
942 {
943 if ( "permission".equals( xmlStreamReader.getLocalName() ) )
944 {
945 rbacDatabase.addPermission( parseJdoPermission( xmlStreamReader, strict ) );
946 }
947 else
948 {
949 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
950 }
951 }
952 }
953 else if ( checkFieldWithDuplicate( xmlStreamReader, "operations", null, parsed ) )
954 {
955 java.util.List operations = new java.util.ArrayList
956 rbacDatabase.setOperations( operations );
957 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
958 {
959 if ( "operation".equals( xmlStreamReader.getLocalName() ) )
960 {
961 rbacDatabase.addOperation( parseJdoOperation( xmlStreamReader, strict ) );
962 }
963 else
964 {
965 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
966 }
967 }
968 }
969 else if ( checkFieldWithDuplicate( xmlStreamReader, "resources", null, parsed ) )
970 {
971 java.util.List resources = new java.util.ArrayList
972 rbacDatabase.setResources( resources );
973 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
974 {
975 if ( "resource".equals( xmlStreamReader.getLocalName() ) )
976 {
977 rbacDatabase.addResource( parseJdoResource( xmlStreamReader, strict ) );
978 }
979 else
980 {
981 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
982 }
983 }
984 }
985 else if ( checkFieldWithDuplicate( xmlStreamReader, "userAssignments", null, parsed ) )
986 {
987 java.util.List userAssignments = new java.util.ArrayList
988 rbacDatabase.setUserAssignments( userAssignments );
989 while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
990 {
991 if ( "userAssignment".equals( xmlStreamReader.getLocalName() ) )
992 {
993 rbacDatabase.addUserAssignment( parseJdoUserAssignment( xmlStreamReader, strict ) );
994 }
995 else
996 {
997 throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
998 }
999 }
1000 }
1001 else
1002 {
1003 checkUnknownElement( xmlStreamReader, strict );
1004 }
1005 }
1006 return rbacDatabase;
1007 }
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018 private RbacDatabase read( XMLStreamReader xmlStreamReader, boolean strict )
1019 throws IOException, XMLStreamException
1020 {
1021 int eventType = xmlStreamReader.getEventType();
1022 String encoding = null;
1023 while ( eventType != XMLStreamConstants.END_DOCUMENT )
1024 {
1025 if ( eventType == XMLStreamConstants.START_DOCUMENT )
1026 {
1027 encoding = xmlStreamReader.getCharacterEncodingScheme();
1028 }
1029 if ( eventType == XMLStreamConstants.START_ELEMENT )
1030 {
1031 if ( strict && ! "rbacDatabase".equals( xmlStreamReader.getLocalName() ) )
1032 {
1033 throw new XMLStreamException( "Expected root element 'rbacDatabase' but found '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation(), null );
1034 }
1035 RbacDatabase rbacDatabase = parseRbacDatabase( xmlStreamReader, strict );
1036 rbacDatabase.setModelEncoding( encoding );
1037 resolveReferences( rbacDatabase );
1038 return rbacDatabase;
1039 }
1040 eventType = xmlStreamReader.next();
1041 }
1042 throw new XMLStreamException( "Expected root element 'rbacDatabase' but found no element at all: invalid XML document", xmlStreamReader.getLocation(), null );
1043 }
1044
1045
1046
1047
1048
1049
1050 private void resolveReferences( RbacDatabase value )
1051 {
1052 java.util.Map refs;
1053 for ( java.util.Iterator i = value.getRoles().iterator(); i.hasNext(); )
1054 {
1055 resolveReferences( (JdoRole) i.next() );
1056 }
1057 for ( java.util.Iterator i = value.getPermissions().iterator(); i.hasNext(); )
1058 {
1059 resolveReferences( (JdoPermission) i.next() );
1060 }
1061 }
1062
1063
1064
1065
1066
1067
1068 private void resolveReferences( JdoRole value )
1069 {
1070 java.util.Map refs;
1071 if ( jdoPermissionReferences != null )
1072 {
1073 refs = (java.util.Map) jdoPermissionReferences.get( value );
1074 if ( refs != null )
1075 {
1076 for ( int i = 0; i < value.getPermissions().size(); i++ )
1077 {
1078 String id = (String) refs.get( "permissions." + i );
1079 JdoPermission ref = (JdoPermission) jdoPermissionInstances.get( id );
1080 if ( ref != null )
1081 {
1082 value.getPermissions().set( i, ref );
1083 }
1084 }
1085 }
1086 }
1087 }
1088
1089
1090
1091
1092
1093
1094 private void resolveReferences( JdoPermission value )
1095 {
1096 java.util.Map refs;
1097 if ( jdoOperationReferences != null )
1098 {
1099 refs = (java.util.Map) jdoOperationReferences.get( value );
1100 if ( refs != null )
1101 {
1102 String id = (String) refs.get( "operation" );
1103 JdoOperation ref = (JdoOperation) jdoOperationInstances.get( id );
1104 if ( ref != null && !ref.equals( value.getOperation() ) )
1105 {
1106 value.setOperation( ref );
1107 }
1108 }
1109 }
1110 if ( jdoResourceReferences != null )
1111 {
1112 refs = (java.util.Map) jdoResourceReferences.get( value );
1113 if ( refs != null )
1114 {
1115 String id = (String) refs.get( "resource" );
1116 JdoResource ref = (JdoResource) jdoResourceInstances.get( id );
1117 if ( ref != null && !ref.equals( value.getResource() ) )
1118 {
1119 value.setResource( ref );
1120 }
1121 }
1122 }
1123 }
1124
1125 }