Source code

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