This project has retired. For details please refer to its Attic page.
RbacJdoModelStaxReader xref
View Javadoc

1   // =================== DO NOT EDIT THIS FILE ====================
2   // Generated by Modello 1.7,
3   // any modifications will be overwritten.
4   // ==============================================================
5   
6   package org.apache.archiva.redback.rbac.jdo.io.stax;
7   
8     //---------------------------------/
9    //- Imported classes and packages -/
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   * Class RbacJdoModelStaxReader.
35   * 
36   * @version $Revision$ $Date$
37   */
38  public class RbacJdoModelStaxReader
39  {
40  
41        //--------------------------/
42       //- Class/Member Variables -/
43      //--------------------------/
44  
45      /**
46       * Field jdoPermissionReferences.
47       */
48      private java.util.Map jdoPermissionReferences;
49  
50      /**
51       * Field jdoPermissionInstances.
52       */
53      private java.util.Map jdoPermissionInstances;
54  
55      /**
56       * Field jdoOperationReferences.
57       */
58      private java.util.Map jdoOperationReferences;
59  
60      /**
61       * Field jdoResourceReferences.
62       */
63      private java.util.Map jdoResourceReferences;
64  
65      /**
66       * Field jdoOperationInstances.
67       */
68      private java.util.Map jdoOperationInstances;
69  
70      /**
71       * Field jdoResourceInstances.
72       */
73      private java.util.Map jdoResourceInstances;
74  
75  
76        //-----------/
77       //- Methods -/
78      //-----------/
79  
80      /**
81       * Method read.
82       * 
83       * @param reader
84       * @param strict
85       * @throws IOException
86       * @throws XMLStreamException
87       * @return RbacDatabase
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      } //-- RbacDatabase read( Reader, boolean )
96  
97      /**
98       * Method read.
99       * 
100      * @param reader
101      * @throws IOException
102      * @throws XMLStreamException
103      * @return RbacDatabase
104      */
105     public RbacDatabase read( Reader reader )
106         throws IOException, XMLStreamException
107     {
108         return read( reader, true );
109     } //-- RbacDatabase read( Reader )
110 
111     /**
112      * Method read.
113      * 
114      * @param stream
115      * @param strict
116      * @throws IOException
117      * @throws XMLStreamException
118      * @return RbacDatabase
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     } //-- RbacDatabase read( InputStream, boolean )
127 
128     /**
129      * Method read.
130      * 
131      * @param stream
132      * @throws IOException
133      * @throws XMLStreamException
134      * @return RbacDatabase
135      */
136     public RbacDatabase read( InputStream stream )
137         throws IOException, XMLStreamException
138     {
139         return read( stream, true );
140     } //-- RbacDatabase read( InputStream )
141 
142     /**
143      * Method read.
144      * 
145      * @param filePath
146      * @param strict
147      * @throws IOException
148      * @throws XMLStreamException
149      * @return RbacDatabase
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     } //-- RbacDatabase read( String, boolean )
159 
160     /**
161      * Method read.
162      * 
163      * @param filePath
164      * @throws IOException
165      * @throws XMLStreamException
166      * @return RbacDatabase
167      */
168     public RbacDatabase read( String filePath )
169         throws IOException, XMLStreamException
170     {
171         return read( filePath, true );
172     } //-- RbacDatabase read( String )
173 
174     /**
175      * Method checkFieldWithDuplicate.
176      * 
177      * @param xmlStreamReader
178      * @param parsed
179      * @param alias
180      * @param tagName
181      * @throws XMLStreamException
182      * @return boolean
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     } //-- boolean checkFieldWithDuplicate( XMLStreamReader, String, String, java.util.Set )
197 
198     /**
199      * Method checkUnknownElement.
200      * 
201      * @param xmlStreamReader
202      * @param strict
203      * @throws XMLStreamException
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     } //-- void checkUnknownElement( XMLStreamReader, boolean )
226 
227     /**
228      * Method getBooleanValue.
229      * 
230      * @param s
231      * @param xmlStreamReader
232      * @param attribute
233      * @throws XMLStreamException
234      * @return boolean
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     } //-- boolean getBooleanValue( String, String, XMLStreamReader )
245 
246     /**
247      * Method getByteValue.
248      * 
249      * @param s
250      * @param strict
251      * @param xmlStreamReader
252      * @param attribute
253      * @throws XMLStreamException
254      * @return byte
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     } //-- byte getByteValue( String, String, XMLStreamReader, boolean )
275 
276     /**
277      * Method getCharacterValue.
278      * 
279      * @param s
280      * @param xmlStreamReader
281      * @param attribute
282      * @throws XMLStreamException
283      * @return char
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     } //-- char getCharacterValue( String, String, XMLStreamReader )
294 
295     /**
296      * Method getDateValue.
297      * 
298      * @param s
299      * @param xmlStreamReader
300      * @param dateFormat
301      * @param attribute
302      * @throws XMLStreamException
303      * @return Date
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     } //-- java.util.Date getDateValue( String, String, String, XMLStreamReader )
341 
342     /**
343      * Method getDefaultValue.
344      * 
345      * @param s
346      * @param v
347      * @return String
348      */
349     private String getDefaultValue( String s, String v )
350     {
351         if ( s == null )
352         {
353             s = v;
354         }
355         return s;
356     } //-- String getDefaultValue( String, String )
357 
358     /**
359      * Method getDoubleValue.
360      * 
361      * @param s
362      * @param strict
363      * @param xmlStreamReader
364      * @param attribute
365      * @throws XMLStreamException
366      * @return double
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     } //-- double getDoubleValue( String, String, XMLStreamReader, boolean )
387 
388     /**
389      * Method getFloatValue.
390      * 
391      * @param s
392      * @param strict
393      * @param xmlStreamReader
394      * @param attribute
395      * @throws XMLStreamException
396      * @return float
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     } //-- float getFloatValue( String, String, XMLStreamReader, boolean )
417 
418     /**
419      * Method getIntegerValue.
420      * 
421      * @param s
422      * @param strict
423      * @param xmlStreamReader
424      * @param attribute
425      * @throws XMLStreamException
426      * @return int
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     } //-- int getIntegerValue( String, String, XMLStreamReader, boolean )
447 
448     /**
449      * Method getLongValue.
450      * 
451      * @param s
452      * @param strict
453      * @param xmlStreamReader
454      * @param attribute
455      * @throws XMLStreamException
456      * @return long
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     } //-- long getLongValue( String, String, XMLStreamReader, boolean )
477 
478     /**
479      * Method getRequiredAttributeValue.
480      * 
481      * @param s
482      * @param strict
483      * @param xmlStreamReader
484      * @param attribute
485      * @throws XMLStreamException
486      * @return String
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     } //-- String getRequiredAttributeValue( String, String, XMLStreamReader, boolean )
500 
501     /**
502      * Method getShortValue.
503      * 
504      * @param s
505      * @param strict
506      * @param xmlStreamReader
507      * @param attribute
508      * @throws XMLStreamException
509      * @return short
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     } //-- short getShortValue( String, String, XMLStreamReader, boolean )
530 
531     /**
532      * Method getTrimmedValue.
533      * 
534      * @param s
535      * @return String
536      */
537     private String getTrimmedValue( String s )
538     {
539         if ( s != null )
540         {
541             s = s.trim();
542         }
543         return s;
544     } //-- String getTrimmedValue( String )
545 
546     /**
547      * Method nextTag.
548      * 
549      * @param xmlStreamReader
550      * @throws XMLStreamException
551      * @return int
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     } //-- int nextTag( XMLStreamReader )
575 
576     /**
577      * Method parseJdoOperation.
578      * 
579      * @param xmlStreamReader
580      * @param strict
581      * @throws IOException
582      * @throws XMLStreamException
583      * @return JdoOperation
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     } //-- JdoOperation parseJdoOperation( XMLStreamReader, boolean )
625 
626     /**
627      * Method parseJdoPermission.
628      * 
629      * @param xmlStreamReader
630      * @param strict
631      * @throws IOException
632      * @throws XMLStreamException
633      * @return JdoPermission
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                     // This is a reference to an element elsewhere in the model
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                     // This is a reference to an element elsewhere in the model
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     } //-- JdoPermission parseJdoPermission( XMLStreamReader, boolean )
717 
718     /**
719      * Method parseJdoResource.
720      * 
721      * @param xmlStreamReader
722      * @param strict
723      * @throws IOException
724      * @throws XMLStreamException
725      * @return JdoResource
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     } //-- JdoResource parseJdoResource( XMLStreamReader, boolean )
763 
764     /**
765      * Method parseJdoRole.
766      * 
767      * @param xmlStreamReader
768      * @param strict
769      * @throws IOException
770      * @throws XMLStreamException
771      * @return JdoRole
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/*<String>*/();
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/*<JdoPermission>*/();
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                             // This is a reference to an element elsewhere in the model
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     } //-- JdoRole parseJdoRole( XMLStreamReader, boolean )
851 
852     /**
853      * Method parseJdoUserAssignment.
854      * 
855      * @param xmlStreamReader
856      * @param strict
857      * @throws IOException
858      * @throws XMLStreamException
859      * @return JdoUserAssignment
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/*<String>*/();
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     } //-- JdoUserAssignment parseJdoUserAssignment( XMLStreamReader, boolean )
904 
905     /**
906      * Method parseRbacDatabase.
907      * 
908      * @param xmlStreamReader
909      * @param strict
910      * @throws IOException
911      * @throws XMLStreamException
912      * @return RbacDatabase
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/*<JdoRole>*/();
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/*<JdoPermission>*/();
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/*<JdoOperation>*/();
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/*<JdoResource>*/();
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/*<JdoUserAssignment>*/();
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     } //-- RbacDatabase parseRbacDatabase( XMLStreamReader, boolean )
1008 
1009     /**
1010      * Method read.
1011      * 
1012      * @param xmlStreamReader
1013      * @param strict
1014      * @throws IOException
1015      * @throws XMLStreamException
1016      * @return RbacDatabase
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     } //-- RbacDatabase read( XMLStreamReader, boolean )
1044 
1045     /**
1046      * Method resolveReferences.
1047      * 
1048      * @param value
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     } //-- void resolveReferences( RbacDatabase )
1062 
1063     /**
1064      * Method resolveReferences.
1065      * 
1066      * @param value
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     } //-- void resolveReferences( JdoRole )
1088 
1089     /**
1090      * Method resolveReferences.
1091      * 
1092      * @param value
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     } //-- void resolveReferences( JdoPermission )
1124 
1125 }