001/*
002 * An XML document type.
003 * Localname: key
004 * Namespace: http://www.springframework.org/schema/beans
005 * Java type: org.springframework.schema.beans.KeyDocument
006 *
007 * Automatically generated - do not modify.
008 */
009package org.springframework.schema.beans.impl;
010/**
011 * A document containing one key(@http://www.springframework.org/schema/beans) element.
012 *
013 * This is a complex type.
014 */
015public class KeyDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.KeyDocument
016{
017    private static final long serialVersionUID = 1L;
018    
019    public KeyDocumentImpl(org.apache.xmlbeans.SchemaType sType)
020    {
021        super(sType);
022    }
023    
024    private static final javax.xml.namespace.QName KEY$0 = 
025        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "key");
026    
027    
028    /**
029     * Gets the "key" element
030     */
031    public org.springframework.schema.beans.KeyDocument.Key getKey()
032    {
033        synchronized (monitor())
034        {
035            check_orphaned();
036            org.springframework.schema.beans.KeyDocument.Key target = null;
037            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0);
038            if (target == null)
039            {
040                return null;
041            }
042            return target;
043        }
044    }
045    
046    /**
047     * Sets the "key" element
048     */
049    public void setKey(org.springframework.schema.beans.KeyDocument.Key key)
050    {
051        synchronized (monitor())
052        {
053            check_orphaned();
054            org.springframework.schema.beans.KeyDocument.Key target = null;
055            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0);
056            if (target == null)
057            {
058                target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0);
059            }
060            target.set(key);
061        }
062    }
063    
064    /**
065     * Appends and returns a new empty "key" element
066     */
067    public org.springframework.schema.beans.KeyDocument.Key addNewKey()
068    {
069        synchronized (monitor())
070        {
071            check_orphaned();
072            org.springframework.schema.beans.KeyDocument.Key target = null;
073            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0);
074            return target;
075        }
076    }
077    /**
078     * An XML key(@http://www.springframework.org/schema/beans).
079     *
080     * This is a complex type.
081     */
082    public static class KeyImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.KeyDocument.Key
083    {
084        private static final long serialVersionUID = 1L;
085        
086        public KeyImpl(org.apache.xmlbeans.SchemaType sType)
087        {
088            super(sType);
089        }
090        
091        private static final javax.xml.namespace.QName DESCRIPTION$0 = 
092            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "description");
093        private static final javax.xml.namespace.QName BEAN$2 = 
094            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "bean");
095        private static final javax.xml.namespace.QName REF$4 = 
096            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "ref");
097        private static final javax.xml.namespace.QName IDREF$6 = 
098            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "idref");
099        private static final javax.xml.namespace.QName VALUE$8 = 
100            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "value");
101        private static final javax.xml.namespace.QName NULL$10 = 
102            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "null");
103        private static final javax.xml.namespace.QName ARRAY$12 = 
104            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "array");
105        private static final javax.xml.namespace.QName LIST$14 = 
106            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "list");
107        private static final javax.xml.namespace.QName SET$16 = 
108            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "set");
109        private static final javax.xml.namespace.QName MAP$18 = 
110            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "map");
111        private static final javax.xml.namespace.QName PROPS$20 = 
112            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "props");
113        
114        
115        /**
116         * Gets the "description" element
117         */
118        public org.springframework.schema.beans.DescriptionDocument.Description getDescription()
119        {
120            synchronized (monitor())
121            {
122                check_orphaned();
123                org.springframework.schema.beans.DescriptionDocument.Description target = null;
124                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
125                if (target == null)
126                {
127                    return null;
128                }
129                return target;
130            }
131        }
132        
133        /**
134         * True if has "description" element
135         */
136        public boolean isSetDescription()
137        {
138            synchronized (monitor())
139            {
140                check_orphaned();
141                return get_store().count_elements(DESCRIPTION$0) != 0;
142            }
143        }
144        
145        /**
146         * Sets the "description" element
147         */
148        public void setDescription(org.springframework.schema.beans.DescriptionDocument.Description description)
149        {
150            synchronized (monitor())
151            {
152                check_orphaned();
153                org.springframework.schema.beans.DescriptionDocument.Description target = null;
154                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
155                if (target == null)
156                {
157                    target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$0);
158                }
159                target.set(description);
160            }
161        }
162        
163        /**
164         * Appends and returns a new empty "description" element
165         */
166        public org.springframework.schema.beans.DescriptionDocument.Description addNewDescription()
167        {
168            synchronized (monitor())
169            {
170                check_orphaned();
171                org.springframework.schema.beans.DescriptionDocument.Description target = null;
172                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$0);
173                return target;
174            }
175        }
176        
177        /**
178         * Unsets the "description" element
179         */
180        public void unsetDescription()
181        {
182            synchronized (monitor())
183            {
184                check_orphaned();
185                get_store().remove_element(DESCRIPTION$0, 0);
186            }
187        }
188        
189        /**
190         * Gets array of all "bean" elements
191         */
192        public org.springframework.schema.beans.BeanDocument.Bean[] getBeanArray()
193        {
194            synchronized (monitor())
195            {
196                check_orphaned();
197                java.util.List targetList = new java.util.ArrayList();
198                get_store().find_all_element_users(BEAN$2, targetList);
199                org.springframework.schema.beans.BeanDocument.Bean[] result = new org.springframework.schema.beans.BeanDocument.Bean[targetList.size()];
200                targetList.toArray(result);
201                return result;
202            }
203        }
204        
205        /**
206         * Gets ith "bean" element
207         */
208        public org.springframework.schema.beans.BeanDocument.Bean getBeanArray(int i)
209        {
210            synchronized (monitor())
211            {
212                check_orphaned();
213                org.springframework.schema.beans.BeanDocument.Bean target = null;
214                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$2, i);
215                if (target == null)
216                {
217                    throw new IndexOutOfBoundsException();
218                }
219                return target;
220            }
221        }
222        
223        /**
224         * Returns number of "bean" element
225         */
226        public int sizeOfBeanArray()
227        {
228            synchronized (monitor())
229            {
230                check_orphaned();
231                return get_store().count_elements(BEAN$2);
232            }
233        }
234        
235        /**
236         * Sets array of all "bean" element
237         */
238        public void setBeanArray(org.springframework.schema.beans.BeanDocument.Bean[] beanArray)
239        {
240            synchronized (monitor())
241            {
242                check_orphaned();
243                arraySetterHelper(beanArray, BEAN$2);
244            }
245        }
246        
247        /**
248         * Sets ith "bean" element
249         */
250        public void setBeanArray(int i, org.springframework.schema.beans.BeanDocument.Bean bean)
251        {
252            synchronized (monitor())
253            {
254                check_orphaned();
255                org.springframework.schema.beans.BeanDocument.Bean target = null;
256                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$2, i);
257                if (target == null)
258                {
259                    throw new IndexOutOfBoundsException();
260                }
261                target.set(bean);
262            }
263        }
264        
265        /**
266         * Inserts and returns a new empty value (as xml) as the ith "bean" element
267         */
268        public org.springframework.schema.beans.BeanDocument.Bean insertNewBean(int i)
269        {
270            synchronized (monitor())
271            {
272                check_orphaned();
273                org.springframework.schema.beans.BeanDocument.Bean target = null;
274                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().insert_element_user(BEAN$2, i);
275                return target;
276            }
277        }
278        
279        /**
280         * Appends and returns a new empty value (as xml) as the last "bean" element
281         */
282        public org.springframework.schema.beans.BeanDocument.Bean addNewBean()
283        {
284            synchronized (monitor())
285            {
286                check_orphaned();
287                org.springframework.schema.beans.BeanDocument.Bean target = null;
288                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$2);
289                return target;
290            }
291        }
292        
293        /**
294         * Removes the ith "bean" element
295         */
296        public void removeBean(int i)
297        {
298            synchronized (monitor())
299            {
300                check_orphaned();
301                get_store().remove_element(BEAN$2, i);
302            }
303        }
304        
305        /**
306         * Gets array of all "ref" elements
307         */
308        public org.springframework.schema.beans.RefDocument.Ref[] getRefArray()
309        {
310            synchronized (monitor())
311            {
312                check_orphaned();
313                java.util.List targetList = new java.util.ArrayList();
314                get_store().find_all_element_users(REF$4, targetList);
315                org.springframework.schema.beans.RefDocument.Ref[] result = new org.springframework.schema.beans.RefDocument.Ref[targetList.size()];
316                targetList.toArray(result);
317                return result;
318            }
319        }
320        
321        /**
322         * Gets ith "ref" element
323         */
324        public org.springframework.schema.beans.RefDocument.Ref getRefArray(int i)
325        {
326            synchronized (monitor())
327            {
328                check_orphaned();
329                org.springframework.schema.beans.RefDocument.Ref target = null;
330                target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$4, i);
331                if (target == null)
332                {
333                    throw new IndexOutOfBoundsException();
334                }
335                return target;
336            }
337        }
338        
339        /**
340         * Returns number of "ref" element
341         */
342        public int sizeOfRefArray()
343        {
344            synchronized (monitor())
345            {
346                check_orphaned();
347                return get_store().count_elements(REF$4);
348            }
349        }
350        
351        /**
352         * Sets array of all "ref" element
353         */
354        public void setRefArray(org.springframework.schema.beans.RefDocument.Ref[] refArray)
355        {
356            synchronized (monitor())
357            {
358                check_orphaned();
359                arraySetterHelper(refArray, REF$4);
360            }
361        }
362        
363        /**
364         * Sets ith "ref" element
365         */
366        public void setRefArray(int i, org.springframework.schema.beans.RefDocument.Ref ref)
367        {
368            synchronized (monitor())
369            {
370                check_orphaned();
371                org.springframework.schema.beans.RefDocument.Ref target = null;
372                target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$4, i);
373                if (target == null)
374                {
375                    throw new IndexOutOfBoundsException();
376                }
377                target.set(ref);
378            }
379        }
380        
381        /**
382         * Inserts and returns a new empty value (as xml) as the ith "ref" element
383         */
384        public org.springframework.schema.beans.RefDocument.Ref insertNewRef(int i)
385        {
386            synchronized (monitor())
387            {
388                check_orphaned();
389                org.springframework.schema.beans.RefDocument.Ref target = null;
390                target = (org.springframework.schema.beans.RefDocument.Ref)get_store().insert_element_user(REF$4, i);
391                return target;
392            }
393        }
394        
395        /**
396         * Appends and returns a new empty value (as xml) as the last "ref" element
397         */
398        public org.springframework.schema.beans.RefDocument.Ref addNewRef()
399        {
400            synchronized (monitor())
401            {
402                check_orphaned();
403                org.springframework.schema.beans.RefDocument.Ref target = null;
404                target = (org.springframework.schema.beans.RefDocument.Ref)get_store().add_element_user(REF$4);
405                return target;
406            }
407        }
408        
409        /**
410         * Removes the ith "ref" element
411         */
412        public void removeRef(int i)
413        {
414            synchronized (monitor())
415            {
416                check_orphaned();
417                get_store().remove_element(REF$4, i);
418            }
419        }
420        
421        /**
422         * Gets array of all "idref" elements
423         */
424        public org.springframework.schema.beans.IdrefDocument.Idref[] getIdrefArray()
425        {
426            synchronized (monitor())
427            {
428                check_orphaned();
429                java.util.List targetList = new java.util.ArrayList();
430                get_store().find_all_element_users(IDREF$6, targetList);
431                org.springframework.schema.beans.IdrefDocument.Idref[] result = new org.springframework.schema.beans.IdrefDocument.Idref[targetList.size()];
432                targetList.toArray(result);
433                return result;
434            }
435        }
436        
437        /**
438         * Gets ith "idref" element
439         */
440        public org.springframework.schema.beans.IdrefDocument.Idref getIdrefArray(int i)
441        {
442            synchronized (monitor())
443            {
444                check_orphaned();
445                org.springframework.schema.beans.IdrefDocument.Idref target = null;
446                target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$6, i);
447                if (target == null)
448                {
449                    throw new IndexOutOfBoundsException();
450                }
451                return target;
452            }
453        }
454        
455        /**
456         * Returns number of "idref" element
457         */
458        public int sizeOfIdrefArray()
459        {
460            synchronized (monitor())
461            {
462                check_orphaned();
463                return get_store().count_elements(IDREF$6);
464            }
465        }
466        
467        /**
468         * Sets array of all "idref" element
469         */
470        public void setIdrefArray(org.springframework.schema.beans.IdrefDocument.Idref[] idrefArray)
471        {
472            synchronized (monitor())
473            {
474                check_orphaned();
475                arraySetterHelper(idrefArray, IDREF$6);
476            }
477        }
478        
479        /**
480         * Sets ith "idref" element
481         */
482        public void setIdrefArray(int i, org.springframework.schema.beans.IdrefDocument.Idref idref)
483        {
484            synchronized (monitor())
485            {
486                check_orphaned();
487                org.springframework.schema.beans.IdrefDocument.Idref target = null;
488                target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$6, i);
489                if (target == null)
490                {
491                    throw new IndexOutOfBoundsException();
492                }
493                target.set(idref);
494            }
495        }
496        
497        /**
498         * Inserts and returns a new empty value (as xml) as the ith "idref" element
499         */
500        public org.springframework.schema.beans.IdrefDocument.Idref insertNewIdref(int i)
501        {
502            synchronized (monitor())
503            {
504                check_orphaned();
505                org.springframework.schema.beans.IdrefDocument.Idref target = null;
506                target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().insert_element_user(IDREF$6, i);
507                return target;
508            }
509        }
510        
511        /**
512         * Appends and returns a new empty value (as xml) as the last "idref" element
513         */
514        public org.springframework.schema.beans.IdrefDocument.Idref addNewIdref()
515        {
516            synchronized (monitor())
517            {
518                check_orphaned();
519                org.springframework.schema.beans.IdrefDocument.Idref target = null;
520                target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().add_element_user(IDREF$6);
521                return target;
522            }
523        }
524        
525        /**
526         * Removes the ith "idref" element
527         */
528        public void removeIdref(int i)
529        {
530            synchronized (monitor())
531            {
532                check_orphaned();
533                get_store().remove_element(IDREF$6, i);
534            }
535        }
536        
537        /**
538         * Gets array of all "value" elements
539         */
540        public org.springframework.schema.beans.ValueDocument.Value[] getValueArray()
541        {
542            synchronized (monitor())
543            {
544                check_orphaned();
545                java.util.List targetList = new java.util.ArrayList();
546                get_store().find_all_element_users(VALUE$8, targetList);
547                org.springframework.schema.beans.ValueDocument.Value[] result = new org.springframework.schema.beans.ValueDocument.Value[targetList.size()];
548                targetList.toArray(result);
549                return result;
550            }
551        }
552        
553        /**
554         * Gets ith "value" element
555         */
556        public org.springframework.schema.beans.ValueDocument.Value getValueArray(int i)
557        {
558            synchronized (monitor())
559            {
560                check_orphaned();
561                org.springframework.schema.beans.ValueDocument.Value target = null;
562                target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$8, i);
563                if (target == null)
564                {
565                    throw new IndexOutOfBoundsException();
566                }
567                return target;
568            }
569        }
570        
571        /**
572         * Returns number of "value" element
573         */
574        public int sizeOfValueArray()
575        {
576            synchronized (monitor())
577            {
578                check_orphaned();
579                return get_store().count_elements(VALUE$8);
580            }
581        }
582        
583        /**
584         * Sets array of all "value" element
585         */
586        public void setValueArray(org.springframework.schema.beans.ValueDocument.Value[] valueArray)
587        {
588            synchronized (monitor())
589            {
590                check_orphaned();
591                arraySetterHelper(valueArray, VALUE$8);
592            }
593        }
594        
595        /**
596         * Sets ith "value" element
597         */
598        public void setValueArray(int i, org.springframework.schema.beans.ValueDocument.Value value)
599        {
600            synchronized (monitor())
601            {
602                check_orphaned();
603                org.springframework.schema.beans.ValueDocument.Value target = null;
604                target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$8, i);
605                if (target == null)
606                {
607                    throw new IndexOutOfBoundsException();
608                }
609                target.set(value);
610            }
611        }
612        
613        /**
614         * Inserts and returns a new empty value (as xml) as the ith "value" element
615         */
616        public org.springframework.schema.beans.ValueDocument.Value insertNewValue(int i)
617        {
618            synchronized (monitor())
619            {
620                check_orphaned();
621                org.springframework.schema.beans.ValueDocument.Value target = null;
622                target = (org.springframework.schema.beans.ValueDocument.Value)get_store().insert_element_user(VALUE$8, i);
623                return target;
624            }
625        }
626        
627        /**
628         * Appends and returns a new empty value (as xml) as the last "value" element
629         */
630        public org.springframework.schema.beans.ValueDocument.Value addNewValue()
631        {
632            synchronized (monitor())
633            {
634                check_orphaned();
635                org.springframework.schema.beans.ValueDocument.Value target = null;
636                target = (org.springframework.schema.beans.ValueDocument.Value)get_store().add_element_user(VALUE$8);
637                return target;
638            }
639        }
640        
641        /**
642         * Removes the ith "value" element
643         */
644        public void removeValue(int i)
645        {
646            synchronized (monitor())
647            {
648                check_orphaned();
649                get_store().remove_element(VALUE$8, i);
650            }
651        }
652        
653        /**
654         * Gets array of all "null" elements
655         */
656        public org.springframework.schema.beans.NullDocument.Null[] getNullArray()
657        {
658            synchronized (monitor())
659            {
660                check_orphaned();
661                java.util.List targetList = new java.util.ArrayList();
662                get_store().find_all_element_users(NULL$10, targetList);
663                org.springframework.schema.beans.NullDocument.Null[] result = new org.springframework.schema.beans.NullDocument.Null[targetList.size()];
664                targetList.toArray(result);
665                return result;
666            }
667        }
668        
669        /**
670         * Gets ith "null" element
671         */
672        public org.springframework.schema.beans.NullDocument.Null getNullArray(int i)
673        {
674            synchronized (monitor())
675            {
676                check_orphaned();
677                org.springframework.schema.beans.NullDocument.Null target = null;
678                target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$10, i);
679                if (target == null)
680                {
681                    throw new IndexOutOfBoundsException();
682                }
683                return target;
684            }
685        }
686        
687        /**
688         * Returns number of "null" element
689         */
690        public int sizeOfNullArray()
691        {
692            synchronized (monitor())
693            {
694                check_orphaned();
695                return get_store().count_elements(NULL$10);
696            }
697        }
698        
699        /**
700         * Sets array of all "null" element
701         */
702        public void setNullArray(org.springframework.schema.beans.NullDocument.Null[] xnullArray)
703        {
704            synchronized (monitor())
705            {
706                check_orphaned();
707                arraySetterHelper(xnullArray, NULL$10);
708            }
709        }
710        
711        /**
712         * Sets ith "null" element
713         */
714        public void setNullArray(int i, org.springframework.schema.beans.NullDocument.Null xnull)
715        {
716            synchronized (monitor())
717            {
718                check_orphaned();
719                org.springframework.schema.beans.NullDocument.Null target = null;
720                target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$10, i);
721                if (target == null)
722                {
723                    throw new IndexOutOfBoundsException();
724                }
725                target.set(xnull);
726            }
727        }
728        
729        /**
730         * Inserts and returns a new empty value (as xml) as the ith "null" element
731         */
732        public org.springframework.schema.beans.NullDocument.Null insertNewNull(int i)
733        {
734            synchronized (monitor())
735            {
736                check_orphaned();
737                org.springframework.schema.beans.NullDocument.Null target = null;
738                target = (org.springframework.schema.beans.NullDocument.Null)get_store().insert_element_user(NULL$10, i);
739                return target;
740            }
741        }
742        
743        /**
744         * Appends and returns a new empty value (as xml) as the last "null" element
745         */
746        public org.springframework.schema.beans.NullDocument.Null addNewNull()
747        {
748            synchronized (monitor())
749            {
750                check_orphaned();
751                org.springframework.schema.beans.NullDocument.Null target = null;
752                target = (org.springframework.schema.beans.NullDocument.Null)get_store().add_element_user(NULL$10);
753                return target;
754            }
755        }
756        
757        /**
758         * Removes the ith "null" element
759         */
760        public void removeNull(int i)
761        {
762            synchronized (monitor())
763            {
764                check_orphaned();
765                get_store().remove_element(NULL$10, i);
766            }
767        }
768        
769        /**
770         * Gets array of all "array" elements
771         */
772        public org.springframework.schema.beans.ArrayDocument.Array[] getArrayArray()
773        {
774            synchronized (monitor())
775            {
776                check_orphaned();
777                java.util.List targetList = new java.util.ArrayList();
778                get_store().find_all_element_users(ARRAY$12, targetList);
779                org.springframework.schema.beans.ArrayDocument.Array[] result = new org.springframework.schema.beans.ArrayDocument.Array[targetList.size()];
780                targetList.toArray(result);
781                return result;
782            }
783        }
784        
785        /**
786         * Gets ith "array" element
787         */
788        public org.springframework.schema.beans.ArrayDocument.Array getArrayArray(int i)
789        {
790            synchronized (monitor())
791            {
792                check_orphaned();
793                org.springframework.schema.beans.ArrayDocument.Array target = null;
794                target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$12, i);
795                if (target == null)
796                {
797                    throw new IndexOutOfBoundsException();
798                }
799                return target;
800            }
801        }
802        
803        /**
804         * Returns number of "array" element
805         */
806        public int sizeOfArrayArray()
807        {
808            synchronized (monitor())
809            {
810                check_orphaned();
811                return get_store().count_elements(ARRAY$12);
812            }
813        }
814        
815        /**
816         * Sets array of all "array" element
817         */
818        public void setArrayArray(org.springframework.schema.beans.ArrayDocument.Array[] arrayArray)
819        {
820            synchronized (monitor())
821            {
822                check_orphaned();
823                arraySetterHelper(arrayArray, ARRAY$12);
824            }
825        }
826        
827        /**
828         * Sets ith "array" element
829         */
830        public void setArrayArray(int i, org.springframework.schema.beans.ArrayDocument.Array array)
831        {
832            synchronized (monitor())
833            {
834                check_orphaned();
835                org.springframework.schema.beans.ArrayDocument.Array target = null;
836                target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$12, i);
837                if (target == null)
838                {
839                    throw new IndexOutOfBoundsException();
840                }
841                target.set(array);
842            }
843        }
844        
845        /**
846         * Inserts and returns a new empty value (as xml) as the ith "array" element
847         */
848        public org.springframework.schema.beans.ArrayDocument.Array insertNewArray(int i)
849        {
850            synchronized (monitor())
851            {
852                check_orphaned();
853                org.springframework.schema.beans.ArrayDocument.Array target = null;
854                target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().insert_element_user(ARRAY$12, i);
855                return target;
856            }
857        }
858        
859        /**
860         * Appends and returns a new empty value (as xml) as the last "array" element
861         */
862        public org.springframework.schema.beans.ArrayDocument.Array addNewArray()
863        {
864            synchronized (monitor())
865            {
866                check_orphaned();
867                org.springframework.schema.beans.ArrayDocument.Array target = null;
868                target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().add_element_user(ARRAY$12);
869                return target;
870            }
871        }
872        
873        /**
874         * Removes the ith "array" element
875         */
876        public void removeArray(int i)
877        {
878            synchronized (monitor())
879            {
880                check_orphaned();
881                get_store().remove_element(ARRAY$12, i);
882            }
883        }
884        
885        /**
886         * Gets array of all "list" elements
887         */
888        public org.springframework.schema.beans.ListDocument.List[] getListArray()
889        {
890            synchronized (monitor())
891            {
892                check_orphaned();
893                java.util.List targetList = new java.util.ArrayList();
894                get_store().find_all_element_users(LIST$14, targetList);
895                org.springframework.schema.beans.ListDocument.List[] result = new org.springframework.schema.beans.ListDocument.List[targetList.size()];
896                targetList.toArray(result);
897                return result;
898            }
899        }
900        
901        /**
902         * Gets ith "list" element
903         */
904        public org.springframework.schema.beans.ListDocument.List getListArray(int i)
905        {
906            synchronized (monitor())
907            {
908                check_orphaned();
909                org.springframework.schema.beans.ListDocument.List target = null;
910                target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$14, i);
911                if (target == null)
912                {
913                    throw new IndexOutOfBoundsException();
914                }
915                return target;
916            }
917        }
918        
919        /**
920         * Returns number of "list" element
921         */
922        public int sizeOfListArray()
923        {
924            synchronized (monitor())
925            {
926                check_orphaned();
927                return get_store().count_elements(LIST$14);
928            }
929        }
930        
931        /**
932         * Sets array of all "list" element
933         */
934        public void setListArray(org.springframework.schema.beans.ListDocument.List[] listArray)
935        {
936            synchronized (monitor())
937            {
938                check_orphaned();
939                arraySetterHelper(listArray, LIST$14);
940            }
941        }
942        
943        /**
944         * Sets ith "list" element
945         */
946        public void setListArray(int i, org.springframework.schema.beans.ListDocument.List list)
947        {
948            synchronized (monitor())
949            {
950                check_orphaned();
951                org.springframework.schema.beans.ListDocument.List target = null;
952                target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$14, i);
953                if (target == null)
954                {
955                    throw new IndexOutOfBoundsException();
956                }
957                target.set(list);
958            }
959        }
960        
961        /**
962         * Inserts and returns a new empty value (as xml) as the ith "list" element
963         */
964        public org.springframework.schema.beans.ListDocument.List insertNewList(int i)
965        {
966            synchronized (monitor())
967            {
968                check_orphaned();
969                org.springframework.schema.beans.ListDocument.List target = null;
970                target = (org.springframework.schema.beans.ListDocument.List)get_store().insert_element_user(LIST$14, i);
971                return target;
972            }
973        }
974        
975        /**
976         * Appends and returns a new empty value (as xml) as the last "list" element
977         */
978        public org.springframework.schema.beans.ListDocument.List addNewList()
979        {
980            synchronized (monitor())
981            {
982                check_orphaned();
983                org.springframework.schema.beans.ListDocument.List target = null;
984                target = (org.springframework.schema.beans.ListDocument.List)get_store().add_element_user(LIST$14);
985                return target;
986            }
987        }
988        
989        /**
990         * Removes the ith "list" element
991         */
992        public void removeList(int i)
993        {
994            synchronized (monitor())
995            {
996                check_orphaned();
997                get_store().remove_element(LIST$14, i);
998            }
999        }
1000        
1001        /**
1002         * Gets array of all "set" elements
1003         */
1004        public org.springframework.schema.beans.SetDocument.Set[] getSetArray()
1005        {
1006            synchronized (monitor())
1007            {
1008                check_orphaned();
1009                java.util.List targetList = new java.util.ArrayList();
1010                get_store().find_all_element_users(SET$16, targetList);
1011                org.springframework.schema.beans.SetDocument.Set[] result = new org.springframework.schema.beans.SetDocument.Set[targetList.size()];
1012                targetList.toArray(result);
1013                return result;
1014            }
1015        }
1016        
1017        /**
1018         * Gets ith "set" element
1019         */
1020        public org.springframework.schema.beans.SetDocument.Set getSetArray(int i)
1021        {
1022            synchronized (monitor())
1023            {
1024                check_orphaned();
1025                org.springframework.schema.beans.SetDocument.Set target = null;
1026                target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$16, i);
1027                if (target == null)
1028                {
1029                    throw new IndexOutOfBoundsException();
1030                }
1031                return target;
1032            }
1033        }
1034        
1035        /**
1036         * Returns number of "set" element
1037         */
1038        public int sizeOfSetArray()
1039        {
1040            synchronized (monitor())
1041            {
1042                check_orphaned();
1043                return get_store().count_elements(SET$16);
1044            }
1045        }
1046        
1047        /**
1048         * Sets array of all "set" element
1049         */
1050        public void setSetArray(org.springframework.schema.beans.SetDocument.Set[] setArray)
1051        {
1052            synchronized (monitor())
1053            {
1054                check_orphaned();
1055                arraySetterHelper(setArray, SET$16);
1056            }
1057        }
1058        
1059        /**
1060         * Sets ith "set" element
1061         */
1062        public void setSetArray(int i, org.springframework.schema.beans.SetDocument.Set set)
1063        {
1064            synchronized (monitor())
1065            {
1066                check_orphaned();
1067                org.springframework.schema.beans.SetDocument.Set target = null;
1068                target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$16, i);
1069                if (target == null)
1070                {
1071                    throw new IndexOutOfBoundsException();
1072                }
1073                target.set(set);
1074            }
1075        }
1076        
1077        /**
1078         * Inserts and returns a new empty value (as xml) as the ith "set" element
1079         */
1080        public org.springframework.schema.beans.SetDocument.Set insertNewSet(int i)
1081        {
1082            synchronized (monitor())
1083            {
1084                check_orphaned();
1085                org.springframework.schema.beans.SetDocument.Set target = null;
1086                target = (org.springframework.schema.beans.SetDocument.Set)get_store().insert_element_user(SET$16, i);
1087                return target;
1088            }
1089        }
1090        
1091        /**
1092         * Appends and returns a new empty value (as xml) as the last "set" element
1093         */
1094        public org.springframework.schema.beans.SetDocument.Set addNewSet()
1095        {
1096            synchronized (monitor())
1097            {
1098                check_orphaned();
1099                org.springframework.schema.beans.SetDocument.Set target = null;
1100                target = (org.springframework.schema.beans.SetDocument.Set)get_store().add_element_user(SET$16);
1101                return target;
1102            }
1103        }
1104        
1105        /**
1106         * Removes the ith "set" element
1107         */
1108        public void removeSet(int i)
1109        {
1110            synchronized (monitor())
1111            {
1112                check_orphaned();
1113                get_store().remove_element(SET$16, i);
1114            }
1115        }
1116        
1117        /**
1118         * Gets array of all "map" elements
1119         */
1120        public org.springframework.schema.beans.MapDocument.Map[] getMapArray()
1121        {
1122            synchronized (monitor())
1123            {
1124                check_orphaned();
1125                java.util.List targetList = new java.util.ArrayList();
1126                get_store().find_all_element_users(MAP$18, targetList);
1127                org.springframework.schema.beans.MapDocument.Map[] result = new org.springframework.schema.beans.MapDocument.Map[targetList.size()];
1128                targetList.toArray(result);
1129                return result;
1130            }
1131        }
1132        
1133        /**
1134         * Gets ith "map" element
1135         */
1136        public org.springframework.schema.beans.MapDocument.Map getMapArray(int i)
1137        {
1138            synchronized (monitor())
1139            {
1140                check_orphaned();
1141                org.springframework.schema.beans.MapDocument.Map target = null;
1142                target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$18, i);
1143                if (target == null)
1144                {
1145                    throw new IndexOutOfBoundsException();
1146                }
1147                return target;
1148            }
1149        }
1150        
1151        /**
1152         * Returns number of "map" element
1153         */
1154        public int sizeOfMapArray()
1155        {
1156            synchronized (monitor())
1157            {
1158                check_orphaned();
1159                return get_store().count_elements(MAP$18);
1160            }
1161        }
1162        
1163        /**
1164         * Sets array of all "map" element
1165         */
1166        public void setMapArray(org.springframework.schema.beans.MapDocument.Map[] mapArray)
1167        {
1168            synchronized (monitor())
1169            {
1170                check_orphaned();
1171                arraySetterHelper(mapArray, MAP$18);
1172            }
1173        }
1174        
1175        /**
1176         * Sets ith "map" element
1177         */
1178        public void setMapArray(int i, org.springframework.schema.beans.MapDocument.Map map)
1179        {
1180            synchronized (monitor())
1181            {
1182                check_orphaned();
1183                org.springframework.schema.beans.MapDocument.Map target = null;
1184                target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$18, i);
1185                if (target == null)
1186                {
1187                    throw new IndexOutOfBoundsException();
1188                }
1189                target.set(map);
1190            }
1191        }
1192        
1193        /**
1194         * Inserts and returns a new empty value (as xml) as the ith "map" element
1195         */
1196        public org.springframework.schema.beans.MapDocument.Map insertNewMap(int i)
1197        {
1198            synchronized (monitor())
1199            {
1200                check_orphaned();
1201                org.springframework.schema.beans.MapDocument.Map target = null;
1202                target = (org.springframework.schema.beans.MapDocument.Map)get_store().insert_element_user(MAP$18, i);
1203                return target;
1204            }
1205        }
1206        
1207        /**
1208         * Appends and returns a new empty value (as xml) as the last "map" element
1209         */
1210        public org.springframework.schema.beans.MapDocument.Map addNewMap()
1211        {
1212            synchronized (monitor())
1213            {
1214                check_orphaned();
1215                org.springframework.schema.beans.MapDocument.Map target = null;
1216                target = (org.springframework.schema.beans.MapDocument.Map)get_store().add_element_user(MAP$18);
1217                return target;
1218            }
1219        }
1220        
1221        /**
1222         * Removes the ith "map" element
1223         */
1224        public void removeMap(int i)
1225        {
1226            synchronized (monitor())
1227            {
1228                check_orphaned();
1229                get_store().remove_element(MAP$18, i);
1230            }
1231        }
1232        
1233        /**
1234         * Gets array of all "props" elements
1235         */
1236        public org.springframework.schema.beans.PropsDocument.Props[] getPropsArray()
1237        {
1238            synchronized (monitor())
1239            {
1240                check_orphaned();
1241                java.util.List targetList = new java.util.ArrayList();
1242                get_store().find_all_element_users(PROPS$20, targetList);
1243                org.springframework.schema.beans.PropsDocument.Props[] result = new org.springframework.schema.beans.PropsDocument.Props[targetList.size()];
1244                targetList.toArray(result);
1245                return result;
1246            }
1247        }
1248        
1249        /**
1250         * Gets ith "props" element
1251         */
1252        public org.springframework.schema.beans.PropsDocument.Props getPropsArray(int i)
1253        {
1254            synchronized (monitor())
1255            {
1256                check_orphaned();
1257                org.springframework.schema.beans.PropsDocument.Props target = null;
1258                target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$20, i);
1259                if (target == null)
1260                {
1261                    throw new IndexOutOfBoundsException();
1262                }
1263                return target;
1264            }
1265        }
1266        
1267        /**
1268         * Returns number of "props" element
1269         */
1270        public int sizeOfPropsArray()
1271        {
1272            synchronized (monitor())
1273            {
1274                check_orphaned();
1275                return get_store().count_elements(PROPS$20);
1276            }
1277        }
1278        
1279        /**
1280         * Sets array of all "props" element
1281         */
1282        public void setPropsArray(org.springframework.schema.beans.PropsDocument.Props[] propsArray)
1283        {
1284            synchronized (monitor())
1285            {
1286                check_orphaned();
1287                arraySetterHelper(propsArray, PROPS$20);
1288            }
1289        }
1290        
1291        /**
1292         * Sets ith "props" element
1293         */
1294        public void setPropsArray(int i, org.springframework.schema.beans.PropsDocument.Props props)
1295        {
1296            synchronized (monitor())
1297            {
1298                check_orphaned();
1299                org.springframework.schema.beans.PropsDocument.Props target = null;
1300                target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$20, i);
1301                if (target == null)
1302                {
1303                    throw new IndexOutOfBoundsException();
1304                }
1305                target.set(props);
1306            }
1307        }
1308        
1309        /**
1310         * Inserts and returns a new empty value (as xml) as the ith "props" element
1311         */
1312        public org.springframework.schema.beans.PropsDocument.Props insertNewProps(int i)
1313        {
1314            synchronized (monitor())
1315            {
1316                check_orphaned();
1317                org.springframework.schema.beans.PropsDocument.Props target = null;
1318                target = (org.springframework.schema.beans.PropsDocument.Props)get_store().insert_element_user(PROPS$20, i);
1319                return target;
1320            }
1321        }
1322        
1323        /**
1324         * Appends and returns a new empty value (as xml) as the last "props" element
1325         */
1326        public org.springframework.schema.beans.PropsDocument.Props addNewProps()
1327        {
1328            synchronized (monitor())
1329            {
1330                check_orphaned();
1331                org.springframework.schema.beans.PropsDocument.Props target = null;
1332                target = (org.springframework.schema.beans.PropsDocument.Props)get_store().add_element_user(PROPS$20);
1333                return target;
1334            }
1335        }
1336        
1337        /**
1338         * Removes the ith "props" element
1339         */
1340        public void removeProps(int i)
1341        {
1342            synchronized (monitor())
1343            {
1344                check_orphaned();
1345                get_store().remove_element(PROPS$20, i);
1346            }
1347        }
1348    }
1349}