001/*
002 * XML Type:  entryType
003 * Namespace: http://www.springframework.org/schema/beans
004 * Java type: org.springframework.schema.beans.EntryType
005 *
006 * Automatically generated - do not modify.
007 */
008package org.springframework.schema.beans.impl;
009/**
010 * An XML entryType(@http://www.springframework.org/schema/beans).
011 *
012 * This is a complex type.
013 */
014public class EntryTypeImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.EntryType
015{
016    private static final long serialVersionUID = 1L;
017    
018    public EntryTypeImpl(org.apache.xmlbeans.SchemaType sType)
019    {
020        super(sType);
021    }
022    
023    private static final javax.xml.namespace.QName KEY$0 = 
024        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "key");
025    private static final javax.xml.namespace.QName DESCRIPTION$2 = 
026        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "description");
027    private static final javax.xml.namespace.QName BEAN$4 = 
028        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "bean");
029    private static final javax.xml.namespace.QName REF$6 = 
030        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "ref");
031    private static final javax.xml.namespace.QName IDREF$8 = 
032        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "idref");
033    private static final javax.xml.namespace.QName VALUE$10 = 
034        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "value");
035    private static final javax.xml.namespace.QName NULL$12 = 
036        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "null");
037    private static final javax.xml.namespace.QName ARRAY$14 = 
038        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "array");
039    private static final javax.xml.namespace.QName LIST$16 = 
040        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "list");
041    private static final javax.xml.namespace.QName SET$18 = 
042        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "set");
043    private static final javax.xml.namespace.QName MAP$20 = 
044        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "map");
045    private static final javax.xml.namespace.QName PROPS$22 = 
046        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "props");
047    private static final javax.xml.namespace.QName KEY2$24 = 
048        new javax.xml.namespace.QName("", "key");
049    private static final javax.xml.namespace.QName KEYREF$26 = 
050        new javax.xml.namespace.QName("", "key-ref");
051    private static final javax.xml.namespace.QName VALUE2$28 = 
052        new javax.xml.namespace.QName("", "value");
053    private static final javax.xml.namespace.QName VALUEREF$30 = 
054        new javax.xml.namespace.QName("", "value-ref");
055    
056    
057    /**
058     * Gets the "key" element
059     */
060    public org.springframework.schema.beans.KeyDocument.Key getKey()
061    {
062        synchronized (monitor())
063        {
064            check_orphaned();
065            org.springframework.schema.beans.KeyDocument.Key target = null;
066            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0);
067            if (target == null)
068            {
069                return null;
070            }
071            return target;
072        }
073    }
074    
075    /**
076     * True if has "key" element
077     */
078    public boolean isSetKey()
079    {
080        synchronized (monitor())
081        {
082            check_orphaned();
083            return get_store().count_elements(KEY$0) != 0;
084        }
085    }
086    
087    /**
088     * Sets the "key" element
089     */
090    public void setKey(org.springframework.schema.beans.KeyDocument.Key key)
091    {
092        synchronized (monitor())
093        {
094            check_orphaned();
095            org.springframework.schema.beans.KeyDocument.Key target = null;
096            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0);
097            if (target == null)
098            {
099                target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0);
100            }
101            target.set(key);
102        }
103    }
104    
105    /**
106     * Appends and returns a new empty "key" element
107     */
108    public org.springframework.schema.beans.KeyDocument.Key addNewKey()
109    {
110        synchronized (monitor())
111        {
112            check_orphaned();
113            org.springframework.schema.beans.KeyDocument.Key target = null;
114            target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0);
115            return target;
116        }
117    }
118    
119    /**
120     * Unsets the "key" element
121     */
122    public void unsetKey()
123    {
124        synchronized (monitor())
125        {
126            check_orphaned();
127            get_store().remove_element(KEY$0, 0);
128        }
129    }
130    
131    /**
132     * Gets the "description" element
133     */
134    public org.springframework.schema.beans.DescriptionDocument.Description getDescription()
135    {
136        synchronized (monitor())
137        {
138            check_orphaned();
139            org.springframework.schema.beans.DescriptionDocument.Description target = null;
140            target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$2, 0);
141            if (target == null)
142            {
143                return null;
144            }
145            return target;
146        }
147    }
148    
149    /**
150     * True if has "description" element
151     */
152    public boolean isSetDescription()
153    {
154        synchronized (monitor())
155        {
156            check_orphaned();
157            return get_store().count_elements(DESCRIPTION$2) != 0;
158        }
159    }
160    
161    /**
162     * Sets the "description" element
163     */
164    public void setDescription(org.springframework.schema.beans.DescriptionDocument.Description description)
165    {
166        synchronized (monitor())
167        {
168            check_orphaned();
169            org.springframework.schema.beans.DescriptionDocument.Description target = null;
170            target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$2, 0);
171            if (target == null)
172            {
173                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$2);
174            }
175            target.set(description);
176        }
177    }
178    
179    /**
180     * Appends and returns a new empty "description" element
181     */
182    public org.springframework.schema.beans.DescriptionDocument.Description addNewDescription()
183    {
184        synchronized (monitor())
185        {
186            check_orphaned();
187            org.springframework.schema.beans.DescriptionDocument.Description target = null;
188            target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$2);
189            return target;
190        }
191    }
192    
193    /**
194     * Unsets the "description" element
195     */
196    public void unsetDescription()
197    {
198        synchronized (monitor())
199        {
200            check_orphaned();
201            get_store().remove_element(DESCRIPTION$2, 0);
202        }
203    }
204    
205    /**
206     * Gets array of all "bean" elements
207     */
208    public org.springframework.schema.beans.BeanDocument.Bean[] getBeanArray()
209    {
210        synchronized (monitor())
211        {
212            check_orphaned();
213            java.util.List targetList = new java.util.ArrayList();
214            get_store().find_all_element_users(BEAN$4, targetList);
215            org.springframework.schema.beans.BeanDocument.Bean[] result = new org.springframework.schema.beans.BeanDocument.Bean[targetList.size()];
216            targetList.toArray(result);
217            return result;
218        }
219    }
220    
221    /**
222     * Gets ith "bean" element
223     */
224    public org.springframework.schema.beans.BeanDocument.Bean getBeanArray(int i)
225    {
226        synchronized (monitor())
227        {
228            check_orphaned();
229            org.springframework.schema.beans.BeanDocument.Bean target = null;
230            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$4, i);
231            if (target == null)
232            {
233                throw new IndexOutOfBoundsException();
234            }
235            return target;
236        }
237    }
238    
239    /**
240     * Returns number of "bean" element
241     */
242    public int sizeOfBeanArray()
243    {
244        synchronized (monitor())
245        {
246            check_orphaned();
247            return get_store().count_elements(BEAN$4);
248        }
249    }
250    
251    /**
252     * Sets array of all "bean" element
253     */
254    public void setBeanArray(org.springframework.schema.beans.BeanDocument.Bean[] beanArray)
255    {
256        synchronized (monitor())
257        {
258            check_orphaned();
259            arraySetterHelper(beanArray, BEAN$4);
260        }
261    }
262    
263    /**
264     * Sets ith "bean" element
265     */
266    public void setBeanArray(int i, org.springframework.schema.beans.BeanDocument.Bean bean)
267    {
268        synchronized (monitor())
269        {
270            check_orphaned();
271            org.springframework.schema.beans.BeanDocument.Bean target = null;
272            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$4, i);
273            if (target == null)
274            {
275                throw new IndexOutOfBoundsException();
276            }
277            target.set(bean);
278        }
279    }
280    
281    /**
282     * Inserts and returns a new empty value (as xml) as the ith "bean" element
283     */
284    public org.springframework.schema.beans.BeanDocument.Bean insertNewBean(int i)
285    {
286        synchronized (monitor())
287        {
288            check_orphaned();
289            org.springframework.schema.beans.BeanDocument.Bean target = null;
290            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().insert_element_user(BEAN$4, i);
291            return target;
292        }
293    }
294    
295    /**
296     * Appends and returns a new empty value (as xml) as the last "bean" element
297     */
298    public org.springframework.schema.beans.BeanDocument.Bean addNewBean()
299    {
300        synchronized (monitor())
301        {
302            check_orphaned();
303            org.springframework.schema.beans.BeanDocument.Bean target = null;
304            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$4);
305            return target;
306        }
307    }
308    
309    /**
310     * Removes the ith "bean" element
311     */
312    public void removeBean(int i)
313    {
314        synchronized (monitor())
315        {
316            check_orphaned();
317            get_store().remove_element(BEAN$4, i);
318        }
319    }
320    
321    /**
322     * Gets array of all "ref" elements
323     */
324    public org.springframework.schema.beans.RefDocument.Ref[] getRefArray()
325    {
326        synchronized (monitor())
327        {
328            check_orphaned();
329            java.util.List targetList = new java.util.ArrayList();
330            get_store().find_all_element_users(REF$6, targetList);
331            org.springframework.schema.beans.RefDocument.Ref[] result = new org.springframework.schema.beans.RefDocument.Ref[targetList.size()];
332            targetList.toArray(result);
333            return result;
334        }
335    }
336    
337    /**
338     * Gets ith "ref" element
339     */
340    public org.springframework.schema.beans.RefDocument.Ref getRefArray(int i)
341    {
342        synchronized (monitor())
343        {
344            check_orphaned();
345            org.springframework.schema.beans.RefDocument.Ref target = null;
346            target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$6, i);
347            if (target == null)
348            {
349                throw new IndexOutOfBoundsException();
350            }
351            return target;
352        }
353    }
354    
355    /**
356     * Returns number of "ref" element
357     */
358    public int sizeOfRefArray()
359    {
360        synchronized (monitor())
361        {
362            check_orphaned();
363            return get_store().count_elements(REF$6);
364        }
365    }
366    
367    /**
368     * Sets array of all "ref" element
369     */
370    public void setRefArray(org.springframework.schema.beans.RefDocument.Ref[] refArray)
371    {
372        synchronized (monitor())
373        {
374            check_orphaned();
375            arraySetterHelper(refArray, REF$6);
376        }
377    }
378    
379    /**
380     * Sets ith "ref" element
381     */
382    public void setRefArray(int i, org.springframework.schema.beans.RefDocument.Ref ref)
383    {
384        synchronized (monitor())
385        {
386            check_orphaned();
387            org.springframework.schema.beans.RefDocument.Ref target = null;
388            target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$6, i);
389            if (target == null)
390            {
391                throw new IndexOutOfBoundsException();
392            }
393            target.set(ref);
394        }
395    }
396    
397    /**
398     * Inserts and returns a new empty value (as xml) as the ith "ref" element
399     */
400    public org.springframework.schema.beans.RefDocument.Ref insertNewRef(int i)
401    {
402        synchronized (monitor())
403        {
404            check_orphaned();
405            org.springframework.schema.beans.RefDocument.Ref target = null;
406            target = (org.springframework.schema.beans.RefDocument.Ref)get_store().insert_element_user(REF$6, i);
407            return target;
408        }
409    }
410    
411    /**
412     * Appends and returns a new empty value (as xml) as the last "ref" element
413     */
414    public org.springframework.schema.beans.RefDocument.Ref addNewRef()
415    {
416        synchronized (monitor())
417        {
418            check_orphaned();
419            org.springframework.schema.beans.RefDocument.Ref target = null;
420            target = (org.springframework.schema.beans.RefDocument.Ref)get_store().add_element_user(REF$6);
421            return target;
422        }
423    }
424    
425    /**
426     * Removes the ith "ref" element
427     */
428    public void removeRef(int i)
429    {
430        synchronized (monitor())
431        {
432            check_orphaned();
433            get_store().remove_element(REF$6, i);
434        }
435    }
436    
437    /**
438     * Gets array of all "idref" elements
439     */
440    public org.springframework.schema.beans.IdrefDocument.Idref[] getIdrefArray()
441    {
442        synchronized (monitor())
443        {
444            check_orphaned();
445            java.util.List targetList = new java.util.ArrayList();
446            get_store().find_all_element_users(IDREF$8, targetList);
447            org.springframework.schema.beans.IdrefDocument.Idref[] result = new org.springframework.schema.beans.IdrefDocument.Idref[targetList.size()];
448            targetList.toArray(result);
449            return result;
450        }
451    }
452    
453    /**
454     * Gets ith "idref" element
455     */
456    public org.springframework.schema.beans.IdrefDocument.Idref getIdrefArray(int i)
457    {
458        synchronized (monitor())
459        {
460            check_orphaned();
461            org.springframework.schema.beans.IdrefDocument.Idref target = null;
462            target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$8, i);
463            if (target == null)
464            {
465                throw new IndexOutOfBoundsException();
466            }
467            return target;
468        }
469    }
470    
471    /**
472     * Returns number of "idref" element
473     */
474    public int sizeOfIdrefArray()
475    {
476        synchronized (monitor())
477        {
478            check_orphaned();
479            return get_store().count_elements(IDREF$8);
480        }
481    }
482    
483    /**
484     * Sets array of all "idref" element
485     */
486    public void setIdrefArray(org.springframework.schema.beans.IdrefDocument.Idref[] idrefArray)
487    {
488        synchronized (monitor())
489        {
490            check_orphaned();
491            arraySetterHelper(idrefArray, IDREF$8);
492        }
493    }
494    
495    /**
496     * Sets ith "idref" element
497     */
498    public void setIdrefArray(int i, org.springframework.schema.beans.IdrefDocument.Idref idref)
499    {
500        synchronized (monitor())
501        {
502            check_orphaned();
503            org.springframework.schema.beans.IdrefDocument.Idref target = null;
504            target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$8, i);
505            if (target == null)
506            {
507                throw new IndexOutOfBoundsException();
508            }
509            target.set(idref);
510        }
511    }
512    
513    /**
514     * Inserts and returns a new empty value (as xml) as the ith "idref" element
515     */
516    public org.springframework.schema.beans.IdrefDocument.Idref insertNewIdref(int i)
517    {
518        synchronized (monitor())
519        {
520            check_orphaned();
521            org.springframework.schema.beans.IdrefDocument.Idref target = null;
522            target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().insert_element_user(IDREF$8, i);
523            return target;
524        }
525    }
526    
527    /**
528     * Appends and returns a new empty value (as xml) as the last "idref" element
529     */
530    public org.springframework.schema.beans.IdrefDocument.Idref addNewIdref()
531    {
532        synchronized (monitor())
533        {
534            check_orphaned();
535            org.springframework.schema.beans.IdrefDocument.Idref target = null;
536            target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().add_element_user(IDREF$8);
537            return target;
538        }
539    }
540    
541    /**
542     * Removes the ith "idref" element
543     */
544    public void removeIdref(int i)
545    {
546        synchronized (monitor())
547        {
548            check_orphaned();
549            get_store().remove_element(IDREF$8, i);
550        }
551    }
552    
553    /**
554     * Gets array of all "value" elements
555     */
556    public org.springframework.schema.beans.ValueDocument.Value[] getValueArray()
557    {
558        synchronized (monitor())
559        {
560            check_orphaned();
561            java.util.List targetList = new java.util.ArrayList();
562            get_store().find_all_element_users(VALUE$10, targetList);
563            org.springframework.schema.beans.ValueDocument.Value[] result = new org.springframework.schema.beans.ValueDocument.Value[targetList.size()];
564            targetList.toArray(result);
565            return result;
566        }
567    }
568    
569    /**
570     * Gets ith "value" element
571     */
572    public org.springframework.schema.beans.ValueDocument.Value getValueArray(int i)
573    {
574        synchronized (monitor())
575        {
576            check_orphaned();
577            org.springframework.schema.beans.ValueDocument.Value target = null;
578            target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$10, i);
579            if (target == null)
580            {
581                throw new IndexOutOfBoundsException();
582            }
583            return target;
584        }
585    }
586    
587    /**
588     * Returns number of "value" element
589     */
590    public int sizeOfValueArray()
591    {
592        synchronized (monitor())
593        {
594            check_orphaned();
595            return get_store().count_elements(VALUE$10);
596        }
597    }
598    
599    /**
600     * Sets array of all "value" element
601     */
602    public void setValueArray(org.springframework.schema.beans.ValueDocument.Value[] valueArray)
603    {
604        synchronized (monitor())
605        {
606            check_orphaned();
607            arraySetterHelper(valueArray, VALUE$10);
608        }
609    }
610    
611    /**
612     * Sets ith "value" element
613     */
614    public void setValueArray(int i, org.springframework.schema.beans.ValueDocument.Value value)
615    {
616        synchronized (monitor())
617        {
618            check_orphaned();
619            org.springframework.schema.beans.ValueDocument.Value target = null;
620            target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$10, i);
621            if (target == null)
622            {
623                throw new IndexOutOfBoundsException();
624            }
625            target.set(value);
626        }
627    }
628    
629    /**
630     * Inserts and returns a new empty value (as xml) as the ith "value" element
631     */
632    public org.springframework.schema.beans.ValueDocument.Value insertNewValue(int i)
633    {
634        synchronized (monitor())
635        {
636            check_orphaned();
637            org.springframework.schema.beans.ValueDocument.Value target = null;
638            target = (org.springframework.schema.beans.ValueDocument.Value)get_store().insert_element_user(VALUE$10, i);
639            return target;
640        }
641    }
642    
643    /**
644     * Appends and returns a new empty value (as xml) as the last "value" element
645     */
646    public org.springframework.schema.beans.ValueDocument.Value addNewValue()
647    {
648        synchronized (monitor())
649        {
650            check_orphaned();
651            org.springframework.schema.beans.ValueDocument.Value target = null;
652            target = (org.springframework.schema.beans.ValueDocument.Value)get_store().add_element_user(VALUE$10);
653            return target;
654        }
655    }
656    
657    /**
658     * Removes the ith "value" element
659     */
660    public void removeValue(int i)
661    {
662        synchronized (monitor())
663        {
664            check_orphaned();
665            get_store().remove_element(VALUE$10, i);
666        }
667    }
668    
669    /**
670     * Gets array of all "null" elements
671     */
672    public org.springframework.schema.beans.NullDocument.Null[] getNullArray()
673    {
674        synchronized (monitor())
675        {
676            check_orphaned();
677            java.util.List targetList = new java.util.ArrayList();
678            get_store().find_all_element_users(NULL$12, targetList);
679            org.springframework.schema.beans.NullDocument.Null[] result = new org.springframework.schema.beans.NullDocument.Null[targetList.size()];
680            targetList.toArray(result);
681            return result;
682        }
683    }
684    
685    /**
686     * Gets ith "null" element
687     */
688    public org.springframework.schema.beans.NullDocument.Null getNullArray(int i)
689    {
690        synchronized (monitor())
691        {
692            check_orphaned();
693            org.springframework.schema.beans.NullDocument.Null target = null;
694            target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$12, i);
695            if (target == null)
696            {
697                throw new IndexOutOfBoundsException();
698            }
699            return target;
700        }
701    }
702    
703    /**
704     * Returns number of "null" element
705     */
706    public int sizeOfNullArray()
707    {
708        synchronized (monitor())
709        {
710            check_orphaned();
711            return get_store().count_elements(NULL$12);
712        }
713    }
714    
715    /**
716     * Sets array of all "null" element
717     */
718    public void setNullArray(org.springframework.schema.beans.NullDocument.Null[] xnullArray)
719    {
720        synchronized (monitor())
721        {
722            check_orphaned();
723            arraySetterHelper(xnullArray, NULL$12);
724        }
725    }
726    
727    /**
728     * Sets ith "null" element
729     */
730    public void setNullArray(int i, org.springframework.schema.beans.NullDocument.Null xnull)
731    {
732        synchronized (monitor())
733        {
734            check_orphaned();
735            org.springframework.schema.beans.NullDocument.Null target = null;
736            target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$12, i);
737            if (target == null)
738            {
739                throw new IndexOutOfBoundsException();
740            }
741            target.set(xnull);
742        }
743    }
744    
745    /**
746     * Inserts and returns a new empty value (as xml) as the ith "null" element
747     */
748    public org.springframework.schema.beans.NullDocument.Null insertNewNull(int i)
749    {
750        synchronized (monitor())
751        {
752            check_orphaned();
753            org.springframework.schema.beans.NullDocument.Null target = null;
754            target = (org.springframework.schema.beans.NullDocument.Null)get_store().insert_element_user(NULL$12, i);
755            return target;
756        }
757    }
758    
759    /**
760     * Appends and returns a new empty value (as xml) as the last "null" element
761     */
762    public org.springframework.schema.beans.NullDocument.Null addNewNull()
763    {
764        synchronized (monitor())
765        {
766            check_orphaned();
767            org.springframework.schema.beans.NullDocument.Null target = null;
768            target = (org.springframework.schema.beans.NullDocument.Null)get_store().add_element_user(NULL$12);
769            return target;
770        }
771    }
772    
773    /**
774     * Removes the ith "null" element
775     */
776    public void removeNull(int i)
777    {
778        synchronized (monitor())
779        {
780            check_orphaned();
781            get_store().remove_element(NULL$12, i);
782        }
783    }
784    
785    /**
786     * Gets array of all "array" elements
787     */
788    public org.springframework.schema.beans.ArrayDocument.Array[] getArrayArray()
789    {
790        synchronized (monitor())
791        {
792            check_orphaned();
793            java.util.List targetList = new java.util.ArrayList();
794            get_store().find_all_element_users(ARRAY$14, targetList);
795            org.springframework.schema.beans.ArrayDocument.Array[] result = new org.springframework.schema.beans.ArrayDocument.Array[targetList.size()];
796            targetList.toArray(result);
797            return result;
798        }
799    }
800    
801    /**
802     * Gets ith "array" element
803     */
804    public org.springframework.schema.beans.ArrayDocument.Array getArrayArray(int i)
805    {
806        synchronized (monitor())
807        {
808            check_orphaned();
809            org.springframework.schema.beans.ArrayDocument.Array target = null;
810            target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$14, i);
811            if (target == null)
812            {
813                throw new IndexOutOfBoundsException();
814            }
815            return target;
816        }
817    }
818    
819    /**
820     * Returns number of "array" element
821     */
822    public int sizeOfArrayArray()
823    {
824        synchronized (monitor())
825        {
826            check_orphaned();
827            return get_store().count_elements(ARRAY$14);
828        }
829    }
830    
831    /**
832     * Sets array of all "array" element
833     */
834    public void setArrayArray(org.springframework.schema.beans.ArrayDocument.Array[] arrayArray)
835    {
836        synchronized (monitor())
837        {
838            check_orphaned();
839            arraySetterHelper(arrayArray, ARRAY$14);
840        }
841    }
842    
843    /**
844     * Sets ith "array" element
845     */
846    public void setArrayArray(int i, org.springframework.schema.beans.ArrayDocument.Array array)
847    {
848        synchronized (monitor())
849        {
850            check_orphaned();
851            org.springframework.schema.beans.ArrayDocument.Array target = null;
852            target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$14, i);
853            if (target == null)
854            {
855                throw new IndexOutOfBoundsException();
856            }
857            target.set(array);
858        }
859    }
860    
861    /**
862     * Inserts and returns a new empty value (as xml) as the ith "array" element
863     */
864    public org.springframework.schema.beans.ArrayDocument.Array insertNewArray(int i)
865    {
866        synchronized (monitor())
867        {
868            check_orphaned();
869            org.springframework.schema.beans.ArrayDocument.Array target = null;
870            target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().insert_element_user(ARRAY$14, i);
871            return target;
872        }
873    }
874    
875    /**
876     * Appends and returns a new empty value (as xml) as the last "array" element
877     */
878    public org.springframework.schema.beans.ArrayDocument.Array addNewArray()
879    {
880        synchronized (monitor())
881        {
882            check_orphaned();
883            org.springframework.schema.beans.ArrayDocument.Array target = null;
884            target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().add_element_user(ARRAY$14);
885            return target;
886        }
887    }
888    
889    /**
890     * Removes the ith "array" element
891     */
892    public void removeArray(int i)
893    {
894        synchronized (monitor())
895        {
896            check_orphaned();
897            get_store().remove_element(ARRAY$14, i);
898        }
899    }
900    
901    /**
902     * Gets array of all "list" elements
903     */
904    public org.springframework.schema.beans.ListDocument.List[] getListArray()
905    {
906        synchronized (monitor())
907        {
908            check_orphaned();
909            java.util.List targetList = new java.util.ArrayList();
910            get_store().find_all_element_users(LIST$16, targetList);
911            org.springframework.schema.beans.ListDocument.List[] result = new org.springframework.schema.beans.ListDocument.List[targetList.size()];
912            targetList.toArray(result);
913            return result;
914        }
915    }
916    
917    /**
918     * Gets ith "list" element
919     */
920    public org.springframework.schema.beans.ListDocument.List getListArray(int i)
921    {
922        synchronized (monitor())
923        {
924            check_orphaned();
925            org.springframework.schema.beans.ListDocument.List target = null;
926            target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$16, i);
927            if (target == null)
928            {
929                throw new IndexOutOfBoundsException();
930            }
931            return target;
932        }
933    }
934    
935    /**
936     * Returns number of "list" element
937     */
938    public int sizeOfListArray()
939    {
940        synchronized (monitor())
941        {
942            check_orphaned();
943            return get_store().count_elements(LIST$16);
944        }
945    }
946    
947    /**
948     * Sets array of all "list" element
949     */
950    public void setListArray(org.springframework.schema.beans.ListDocument.List[] listArray)
951    {
952        synchronized (monitor())
953        {
954            check_orphaned();
955            arraySetterHelper(listArray, LIST$16);
956        }
957    }
958    
959    /**
960     * Sets ith "list" element
961     */
962    public void setListArray(int i, org.springframework.schema.beans.ListDocument.List list)
963    {
964        synchronized (monitor())
965        {
966            check_orphaned();
967            org.springframework.schema.beans.ListDocument.List target = null;
968            target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$16, i);
969            if (target == null)
970            {
971                throw new IndexOutOfBoundsException();
972            }
973            target.set(list);
974        }
975    }
976    
977    /**
978     * Inserts and returns a new empty value (as xml) as the ith "list" element
979     */
980    public org.springframework.schema.beans.ListDocument.List insertNewList(int i)
981    {
982        synchronized (monitor())
983        {
984            check_orphaned();
985            org.springframework.schema.beans.ListDocument.List target = null;
986            target = (org.springframework.schema.beans.ListDocument.List)get_store().insert_element_user(LIST$16, i);
987            return target;
988        }
989    }
990    
991    /**
992     * Appends and returns a new empty value (as xml) as the last "list" element
993     */
994    public org.springframework.schema.beans.ListDocument.List addNewList()
995    {
996        synchronized (monitor())
997        {
998            check_orphaned();
999            org.springframework.schema.beans.ListDocument.List target = null;
1000            target = (org.springframework.schema.beans.ListDocument.List)get_store().add_element_user(LIST$16);
1001            return target;
1002        }
1003    }
1004    
1005    /**
1006     * Removes the ith "list" element
1007     */
1008    public void removeList(int i)
1009    {
1010        synchronized (monitor())
1011        {
1012            check_orphaned();
1013            get_store().remove_element(LIST$16, i);
1014        }
1015    }
1016    
1017    /**
1018     * Gets array of all "set" elements
1019     */
1020    public org.springframework.schema.beans.SetDocument.Set[] getSetArray()
1021    {
1022        synchronized (monitor())
1023        {
1024            check_orphaned();
1025            java.util.List targetList = new java.util.ArrayList();
1026            get_store().find_all_element_users(SET$18, targetList);
1027            org.springframework.schema.beans.SetDocument.Set[] result = new org.springframework.schema.beans.SetDocument.Set[targetList.size()];
1028            targetList.toArray(result);
1029            return result;
1030        }
1031    }
1032    
1033    /**
1034     * Gets ith "set" element
1035     */
1036    public org.springframework.schema.beans.SetDocument.Set getSetArray(int i)
1037    {
1038        synchronized (monitor())
1039        {
1040            check_orphaned();
1041            org.springframework.schema.beans.SetDocument.Set target = null;
1042            target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$18, i);
1043            if (target == null)
1044            {
1045                throw new IndexOutOfBoundsException();
1046            }
1047            return target;
1048        }
1049    }
1050    
1051    /**
1052     * Returns number of "set" element
1053     */
1054    public int sizeOfSetArray()
1055    {
1056        synchronized (monitor())
1057        {
1058            check_orphaned();
1059            return get_store().count_elements(SET$18);
1060        }
1061    }
1062    
1063    /**
1064     * Sets array of all "set" element
1065     */
1066    public void setSetArray(org.springframework.schema.beans.SetDocument.Set[] setArray)
1067    {
1068        synchronized (monitor())
1069        {
1070            check_orphaned();
1071            arraySetterHelper(setArray, SET$18);
1072        }
1073    }
1074    
1075    /**
1076     * Sets ith "set" element
1077     */
1078    public void setSetArray(int i, org.springframework.schema.beans.SetDocument.Set set)
1079    {
1080        synchronized (monitor())
1081        {
1082            check_orphaned();
1083            org.springframework.schema.beans.SetDocument.Set target = null;
1084            target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$18, i);
1085            if (target == null)
1086            {
1087                throw new IndexOutOfBoundsException();
1088            }
1089            target.set(set);
1090        }
1091    }
1092    
1093    /**
1094     * Inserts and returns a new empty value (as xml) as the ith "set" element
1095     */
1096    public org.springframework.schema.beans.SetDocument.Set insertNewSet(int i)
1097    {
1098        synchronized (monitor())
1099        {
1100            check_orphaned();
1101            org.springframework.schema.beans.SetDocument.Set target = null;
1102            target = (org.springframework.schema.beans.SetDocument.Set)get_store().insert_element_user(SET$18, i);
1103            return target;
1104        }
1105    }
1106    
1107    /**
1108     * Appends and returns a new empty value (as xml) as the last "set" element
1109     */
1110    public org.springframework.schema.beans.SetDocument.Set addNewSet()
1111    {
1112        synchronized (monitor())
1113        {
1114            check_orphaned();
1115            org.springframework.schema.beans.SetDocument.Set target = null;
1116            target = (org.springframework.schema.beans.SetDocument.Set)get_store().add_element_user(SET$18);
1117            return target;
1118        }
1119    }
1120    
1121    /**
1122     * Removes the ith "set" element
1123     */
1124    public void removeSet(int i)
1125    {
1126        synchronized (monitor())
1127        {
1128            check_orphaned();
1129            get_store().remove_element(SET$18, i);
1130        }
1131    }
1132    
1133    /**
1134     * Gets array of all "map" elements
1135     */
1136    public org.springframework.schema.beans.MapDocument.Map[] getMapArray()
1137    {
1138        synchronized (monitor())
1139        {
1140            check_orphaned();
1141            java.util.List targetList = new java.util.ArrayList();
1142            get_store().find_all_element_users(MAP$20, targetList);
1143            org.springframework.schema.beans.MapDocument.Map[] result = new org.springframework.schema.beans.MapDocument.Map[targetList.size()];
1144            targetList.toArray(result);
1145            return result;
1146        }
1147    }
1148    
1149    /**
1150     * Gets ith "map" element
1151     */
1152    public org.springframework.schema.beans.MapDocument.Map getMapArray(int i)
1153    {
1154        synchronized (monitor())
1155        {
1156            check_orphaned();
1157            org.springframework.schema.beans.MapDocument.Map target = null;
1158            target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$20, i);
1159            if (target == null)
1160            {
1161                throw new IndexOutOfBoundsException();
1162            }
1163            return target;
1164        }
1165    }
1166    
1167    /**
1168     * Returns number of "map" element
1169     */
1170    public int sizeOfMapArray()
1171    {
1172        synchronized (monitor())
1173        {
1174            check_orphaned();
1175            return get_store().count_elements(MAP$20);
1176        }
1177    }
1178    
1179    /**
1180     * Sets array of all "map" element
1181     */
1182    public void setMapArray(org.springframework.schema.beans.MapDocument.Map[] mapArray)
1183    {
1184        synchronized (monitor())
1185        {
1186            check_orphaned();
1187            arraySetterHelper(mapArray, MAP$20);
1188        }
1189    }
1190    
1191    /**
1192     * Sets ith "map" element
1193     */
1194    public void setMapArray(int i, org.springframework.schema.beans.MapDocument.Map map)
1195    {
1196        synchronized (monitor())
1197        {
1198            check_orphaned();
1199            org.springframework.schema.beans.MapDocument.Map target = null;
1200            target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$20, i);
1201            if (target == null)
1202            {
1203                throw new IndexOutOfBoundsException();
1204            }
1205            target.set(map);
1206        }
1207    }
1208    
1209    /**
1210     * Inserts and returns a new empty value (as xml) as the ith "map" element
1211     */
1212    public org.springframework.schema.beans.MapDocument.Map insertNewMap(int i)
1213    {
1214        synchronized (monitor())
1215        {
1216            check_orphaned();
1217            org.springframework.schema.beans.MapDocument.Map target = null;
1218            target = (org.springframework.schema.beans.MapDocument.Map)get_store().insert_element_user(MAP$20, i);
1219            return target;
1220        }
1221    }
1222    
1223    /**
1224     * Appends and returns a new empty value (as xml) as the last "map" element
1225     */
1226    public org.springframework.schema.beans.MapDocument.Map addNewMap()
1227    {
1228        synchronized (monitor())
1229        {
1230            check_orphaned();
1231            org.springframework.schema.beans.MapDocument.Map target = null;
1232            target = (org.springframework.schema.beans.MapDocument.Map)get_store().add_element_user(MAP$20);
1233            return target;
1234        }
1235    }
1236    
1237    /**
1238     * Removes the ith "map" element
1239     */
1240    public void removeMap(int i)
1241    {
1242        synchronized (monitor())
1243        {
1244            check_orphaned();
1245            get_store().remove_element(MAP$20, i);
1246        }
1247    }
1248    
1249    /**
1250     * Gets array of all "props" elements
1251     */
1252    public org.springframework.schema.beans.PropsDocument.Props[] getPropsArray()
1253    {
1254        synchronized (monitor())
1255        {
1256            check_orphaned();
1257            java.util.List targetList = new java.util.ArrayList();
1258            get_store().find_all_element_users(PROPS$22, targetList);
1259            org.springframework.schema.beans.PropsDocument.Props[] result = new org.springframework.schema.beans.PropsDocument.Props[targetList.size()];
1260            targetList.toArray(result);
1261            return result;
1262        }
1263    }
1264    
1265    /**
1266     * Gets ith "props" element
1267     */
1268    public org.springframework.schema.beans.PropsDocument.Props getPropsArray(int i)
1269    {
1270        synchronized (monitor())
1271        {
1272            check_orphaned();
1273            org.springframework.schema.beans.PropsDocument.Props target = null;
1274            target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$22, i);
1275            if (target == null)
1276            {
1277                throw new IndexOutOfBoundsException();
1278            }
1279            return target;
1280        }
1281    }
1282    
1283    /**
1284     * Returns number of "props" element
1285     */
1286    public int sizeOfPropsArray()
1287    {
1288        synchronized (monitor())
1289        {
1290            check_orphaned();
1291            return get_store().count_elements(PROPS$22);
1292        }
1293    }
1294    
1295    /**
1296     * Sets array of all "props" element
1297     */
1298    public void setPropsArray(org.springframework.schema.beans.PropsDocument.Props[] propsArray)
1299    {
1300        synchronized (monitor())
1301        {
1302            check_orphaned();
1303            arraySetterHelper(propsArray, PROPS$22);
1304        }
1305    }
1306    
1307    /**
1308     * Sets ith "props" element
1309     */
1310    public void setPropsArray(int i, org.springframework.schema.beans.PropsDocument.Props props)
1311    {
1312        synchronized (monitor())
1313        {
1314            check_orphaned();
1315            org.springframework.schema.beans.PropsDocument.Props target = null;
1316            target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$22, i);
1317            if (target == null)
1318            {
1319                throw new IndexOutOfBoundsException();
1320            }
1321            target.set(props);
1322        }
1323    }
1324    
1325    /**
1326     * Inserts and returns a new empty value (as xml) as the ith "props" element
1327     */
1328    public org.springframework.schema.beans.PropsDocument.Props insertNewProps(int i)
1329    {
1330        synchronized (monitor())
1331        {
1332            check_orphaned();
1333            org.springframework.schema.beans.PropsDocument.Props target = null;
1334            target = (org.springframework.schema.beans.PropsDocument.Props)get_store().insert_element_user(PROPS$22, i);
1335            return target;
1336        }
1337    }
1338    
1339    /**
1340     * Appends and returns a new empty value (as xml) as the last "props" element
1341     */
1342    public org.springframework.schema.beans.PropsDocument.Props addNewProps()
1343    {
1344        synchronized (monitor())
1345        {
1346            check_orphaned();
1347            org.springframework.schema.beans.PropsDocument.Props target = null;
1348            target = (org.springframework.schema.beans.PropsDocument.Props)get_store().add_element_user(PROPS$22);
1349            return target;
1350        }
1351    }
1352    
1353    /**
1354     * Removes the ith "props" element
1355     */
1356    public void removeProps(int i)
1357    {
1358        synchronized (monitor())
1359        {
1360            check_orphaned();
1361            get_store().remove_element(PROPS$22, i);
1362        }
1363    }
1364    
1365    /**
1366     * Gets the "key" attribute
1367     */
1368    public java.lang.String getKey2()
1369    {
1370        synchronized (monitor())
1371        {
1372            check_orphaned();
1373            org.apache.xmlbeans.SimpleValue target = null;
1374            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEY2$24);
1375            if (target == null)
1376            {
1377                return null;
1378            }
1379            return target.getStringValue();
1380        }
1381    }
1382    
1383    /**
1384     * Gets (as xml) the "key" attribute
1385     */
1386    public org.apache.xmlbeans.XmlString xgetKey2()
1387    {
1388        synchronized (monitor())
1389        {
1390            check_orphaned();
1391            org.apache.xmlbeans.XmlString target = null;
1392            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEY2$24);
1393            return target;
1394        }
1395    }
1396    
1397    /**
1398     * True if has "key" attribute
1399     */
1400    public boolean isSetKey2()
1401    {
1402        synchronized (monitor())
1403        {
1404            check_orphaned();
1405            return get_store().find_attribute_user(KEY2$24) != null;
1406        }
1407    }
1408    
1409    /**
1410     * Sets the "key" attribute
1411     */
1412    public void setKey2(java.lang.String key2)
1413    {
1414        synchronized (monitor())
1415        {
1416            check_orphaned();
1417            org.apache.xmlbeans.SimpleValue target = null;
1418            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEY2$24);
1419            if (target == null)
1420            {
1421                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(KEY2$24);
1422            }
1423            target.setStringValue(key2);
1424        }
1425    }
1426    
1427    /**
1428     * Sets (as xml) the "key" attribute
1429     */
1430    public void xsetKey2(org.apache.xmlbeans.XmlString key2)
1431    {
1432        synchronized (monitor())
1433        {
1434            check_orphaned();
1435            org.apache.xmlbeans.XmlString target = null;
1436            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEY2$24);
1437            if (target == null)
1438            {
1439                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(KEY2$24);
1440            }
1441            target.set(key2);
1442        }
1443    }
1444    
1445    /**
1446     * Unsets the "key" attribute
1447     */
1448    public void unsetKey2()
1449    {
1450        synchronized (monitor())
1451        {
1452            check_orphaned();
1453            get_store().remove_attribute(KEY2$24);
1454        }
1455    }
1456    
1457    /**
1458     * Gets the "key-ref" attribute
1459     */
1460    public java.lang.String getKeyRef()
1461    {
1462        synchronized (monitor())
1463        {
1464            check_orphaned();
1465            org.apache.xmlbeans.SimpleValue target = null;
1466            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEYREF$26);
1467            if (target == null)
1468            {
1469                return null;
1470            }
1471            return target.getStringValue();
1472        }
1473    }
1474    
1475    /**
1476     * Gets (as xml) the "key-ref" attribute
1477     */
1478    public org.apache.xmlbeans.XmlString xgetKeyRef()
1479    {
1480        synchronized (monitor())
1481        {
1482            check_orphaned();
1483            org.apache.xmlbeans.XmlString target = null;
1484            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEYREF$26);
1485            return target;
1486        }
1487    }
1488    
1489    /**
1490     * True if has "key-ref" attribute
1491     */
1492    public boolean isSetKeyRef()
1493    {
1494        synchronized (monitor())
1495        {
1496            check_orphaned();
1497            return get_store().find_attribute_user(KEYREF$26) != null;
1498        }
1499    }
1500    
1501    /**
1502     * Sets the "key-ref" attribute
1503     */
1504    public void setKeyRef(java.lang.String keyRef)
1505    {
1506        synchronized (monitor())
1507        {
1508            check_orphaned();
1509            org.apache.xmlbeans.SimpleValue target = null;
1510            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEYREF$26);
1511            if (target == null)
1512            {
1513                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(KEYREF$26);
1514            }
1515            target.setStringValue(keyRef);
1516        }
1517    }
1518    
1519    /**
1520     * Sets (as xml) the "key-ref" attribute
1521     */
1522    public void xsetKeyRef(org.apache.xmlbeans.XmlString keyRef)
1523    {
1524        synchronized (monitor())
1525        {
1526            check_orphaned();
1527            org.apache.xmlbeans.XmlString target = null;
1528            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEYREF$26);
1529            if (target == null)
1530            {
1531                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(KEYREF$26);
1532            }
1533            target.set(keyRef);
1534        }
1535    }
1536    
1537    /**
1538     * Unsets the "key-ref" attribute
1539     */
1540    public void unsetKeyRef()
1541    {
1542        synchronized (monitor())
1543        {
1544            check_orphaned();
1545            get_store().remove_attribute(KEYREF$26);
1546        }
1547    }
1548    
1549    /**
1550     * Gets the "value" attribute
1551     */
1552    public java.lang.String getValue2()
1553    {
1554        synchronized (monitor())
1555        {
1556            check_orphaned();
1557            org.apache.xmlbeans.SimpleValue target = null;
1558            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUE2$28);
1559            if (target == null)
1560            {
1561                return null;
1562            }
1563            return target.getStringValue();
1564        }
1565    }
1566    
1567    /**
1568     * Gets (as xml) the "value" attribute
1569     */
1570    public org.apache.xmlbeans.XmlString xgetValue2()
1571    {
1572        synchronized (monitor())
1573        {
1574            check_orphaned();
1575            org.apache.xmlbeans.XmlString target = null;
1576            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUE2$28);
1577            return target;
1578        }
1579    }
1580    
1581    /**
1582     * True if has "value" attribute
1583     */
1584    public boolean isSetValue2()
1585    {
1586        synchronized (monitor())
1587        {
1588            check_orphaned();
1589            return get_store().find_attribute_user(VALUE2$28) != null;
1590        }
1591    }
1592    
1593    /**
1594     * Sets the "value" attribute
1595     */
1596    public void setValue2(java.lang.String value2)
1597    {
1598        synchronized (monitor())
1599        {
1600            check_orphaned();
1601            org.apache.xmlbeans.SimpleValue target = null;
1602            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUE2$28);
1603            if (target == null)
1604            {
1605                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VALUE2$28);
1606            }
1607            target.setStringValue(value2);
1608        }
1609    }
1610    
1611    /**
1612     * Sets (as xml) the "value" attribute
1613     */
1614    public void xsetValue2(org.apache.xmlbeans.XmlString value2)
1615    {
1616        synchronized (monitor())
1617        {
1618            check_orphaned();
1619            org.apache.xmlbeans.XmlString target = null;
1620            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUE2$28);
1621            if (target == null)
1622            {
1623                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(VALUE2$28);
1624            }
1625            target.set(value2);
1626        }
1627    }
1628    
1629    /**
1630     * Unsets the "value" attribute
1631     */
1632    public void unsetValue2()
1633    {
1634        synchronized (monitor())
1635        {
1636            check_orphaned();
1637            get_store().remove_attribute(VALUE2$28);
1638        }
1639    }
1640    
1641    /**
1642     * Gets the "value-ref" attribute
1643     */
1644    public java.lang.String getValueRef()
1645    {
1646        synchronized (monitor())
1647        {
1648            check_orphaned();
1649            org.apache.xmlbeans.SimpleValue target = null;
1650            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUEREF$30);
1651            if (target == null)
1652            {
1653                return null;
1654            }
1655            return target.getStringValue();
1656        }
1657    }
1658    
1659    /**
1660     * Gets (as xml) the "value-ref" attribute
1661     */
1662    public org.apache.xmlbeans.XmlString xgetValueRef()
1663    {
1664        synchronized (monitor())
1665        {
1666            check_orphaned();
1667            org.apache.xmlbeans.XmlString target = null;
1668            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUEREF$30);
1669            return target;
1670        }
1671    }
1672    
1673    /**
1674     * True if has "value-ref" attribute
1675     */
1676    public boolean isSetValueRef()
1677    {
1678        synchronized (monitor())
1679        {
1680            check_orphaned();
1681            return get_store().find_attribute_user(VALUEREF$30) != null;
1682        }
1683    }
1684    
1685    /**
1686     * Sets the "value-ref" attribute
1687     */
1688    public void setValueRef(java.lang.String valueRef)
1689    {
1690        synchronized (monitor())
1691        {
1692            check_orphaned();
1693            org.apache.xmlbeans.SimpleValue target = null;
1694            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUEREF$30);
1695            if (target == null)
1696            {
1697                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VALUEREF$30);
1698            }
1699            target.setStringValue(valueRef);
1700        }
1701    }
1702    
1703    /**
1704     * Sets (as xml) the "value-ref" attribute
1705     */
1706    public void xsetValueRef(org.apache.xmlbeans.XmlString valueRef)
1707    {
1708        synchronized (monitor())
1709        {
1710            check_orphaned();
1711            org.apache.xmlbeans.XmlString target = null;
1712            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUEREF$30);
1713            if (target == null)
1714            {
1715                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(VALUEREF$30);
1716            }
1717            target.set(valueRef);
1718        }
1719    }
1720    
1721    /**
1722     * Unsets the "value-ref" attribute
1723     */
1724    public void unsetValueRef()
1725    {
1726        synchronized (monitor())
1727        {
1728            check_orphaned();
1729            get_store().remove_attribute(VALUEREF$30);
1730        }
1731    }
1732}