View Javadoc

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