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