001/*
002 * An XML document type.
003 * Localname: beans
004 * Namespace: http://www.springframework.org/schema/beans
005 * Java type: org.springframework.schema.beans.BeansDocument
006 *
007 * Automatically generated - do not modify.
008 */
009package org.springframework.schema.beans.impl;
010/**
011 * A document containing one beans(@http://www.springframework.org/schema/beans) element.
012 *
013 * This is a complex type.
014 */
015public class BeansDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.BeansDocument
016{
017    private static final long serialVersionUID = 1L;
018    
019    public BeansDocumentImpl(org.apache.xmlbeans.SchemaType sType)
020    {
021        super(sType);
022    }
023    
024    private static final javax.xml.namespace.QName BEANS$0 = 
025        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "beans");
026    
027    
028    /**
029     * Gets the "beans" element
030     */
031    public org.springframework.schema.beans.BeansDocument.Beans getBeans()
032    {
033        synchronized (monitor())
034        {
035            check_orphaned();
036            org.springframework.schema.beans.BeansDocument.Beans target = null;
037            target = (org.springframework.schema.beans.BeansDocument.Beans)get_store().find_element_user(BEANS$0, 0);
038            if (target == null)
039            {
040                return null;
041            }
042            return target;
043        }
044    }
045    
046    /**
047     * Sets the "beans" element
048     */
049    public void setBeans(org.springframework.schema.beans.BeansDocument.Beans beans)
050    {
051        synchronized (monitor())
052        {
053            check_orphaned();
054            org.springframework.schema.beans.BeansDocument.Beans target = null;
055            target = (org.springframework.schema.beans.BeansDocument.Beans)get_store().find_element_user(BEANS$0, 0);
056            if (target == null)
057            {
058                target = (org.springframework.schema.beans.BeansDocument.Beans)get_store().add_element_user(BEANS$0);
059            }
060            target.set(beans);
061        }
062    }
063    
064    /**
065     * Appends and returns a new empty "beans" element
066     */
067    public org.springframework.schema.beans.BeansDocument.Beans addNewBeans()
068    {
069        synchronized (monitor())
070        {
071            check_orphaned();
072            org.springframework.schema.beans.BeansDocument.Beans target = null;
073            target = (org.springframework.schema.beans.BeansDocument.Beans)get_store().add_element_user(BEANS$0);
074            return target;
075        }
076    }
077    /**
078     * An XML beans(@http://www.springframework.org/schema/beans).
079     *
080     * This is a complex type.
081     */
082    public static class BeansImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.BeansDocument.Beans
083    {
084        private static final long serialVersionUID = 1L;
085        
086        public BeansImpl(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 IMPORT$2 = 
094            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "import");
095        private static final javax.xml.namespace.QName ALIAS$4 = 
096            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "alias");
097        private static final javax.xml.namespace.QName BEAN$6 = 
098            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "bean");
099        private static final javax.xml.namespace.QName DEFAULTLAZYINIT$8 = 
100            new javax.xml.namespace.QName("", "default-lazy-init");
101        private static final javax.xml.namespace.QName DEFAULTMERGE$10 = 
102            new javax.xml.namespace.QName("", "default-merge");
103        private static final javax.xml.namespace.QName DEFAULTAUTOWIRE$12 = 
104            new javax.xml.namespace.QName("", "default-autowire");
105        private static final javax.xml.namespace.QName DEFAULTAUTOWIRECANDIDATES$14 = 
106            new javax.xml.namespace.QName("", "default-autowire-candidates");
107        private static final javax.xml.namespace.QName DEFAULTINITMETHOD$16 = 
108            new javax.xml.namespace.QName("", "default-init-method");
109        private static final javax.xml.namespace.QName DEFAULTDESTROYMETHOD$18 = 
110            new javax.xml.namespace.QName("", "default-destroy-method");
111        
112        
113        /**
114         * Gets the "description" element
115         */
116        public org.springframework.schema.beans.DescriptionDocument.Description getDescription()
117        {
118            synchronized (monitor())
119            {
120                check_orphaned();
121                org.springframework.schema.beans.DescriptionDocument.Description target = null;
122                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
123                if (target == null)
124                {
125                    return null;
126                }
127                return target;
128            }
129        }
130        
131        /**
132         * True if has "description" element
133         */
134        public boolean isSetDescription()
135        {
136            synchronized (monitor())
137            {
138                check_orphaned();
139                return get_store().count_elements(DESCRIPTION$0) != 0;
140            }
141        }
142        
143        /**
144         * Sets the "description" element
145         */
146        public void setDescription(org.springframework.schema.beans.DescriptionDocument.Description description)
147        {
148            synchronized (monitor())
149            {
150                check_orphaned();
151                org.springframework.schema.beans.DescriptionDocument.Description target = null;
152                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
153                if (target == null)
154                {
155                    target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$0);
156                }
157                target.set(description);
158            }
159        }
160        
161        /**
162         * Appends and returns a new empty "description" element
163         */
164        public org.springframework.schema.beans.DescriptionDocument.Description addNewDescription()
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().add_element_user(DESCRIPTION$0);
171                return target;
172            }
173        }
174        
175        /**
176         * Unsets the "description" element
177         */
178        public void unsetDescription()
179        {
180            synchronized (monitor())
181            {
182                check_orphaned();
183                get_store().remove_element(DESCRIPTION$0, 0);
184            }
185        }
186        
187        /**
188         * Gets array of all "import" elements
189         */
190        public org.springframework.schema.beans.ImportDocument.Import[] getImportArray()
191        {
192            synchronized (monitor())
193            {
194                check_orphaned();
195                java.util.List targetList = new java.util.ArrayList();
196                get_store().find_all_element_users(IMPORT$2, targetList);
197                org.springframework.schema.beans.ImportDocument.Import[] result = new org.springframework.schema.beans.ImportDocument.Import[targetList.size()];
198                targetList.toArray(result);
199                return result;
200            }
201        }
202        
203        /**
204         * Gets ith "import" element
205         */
206        public org.springframework.schema.beans.ImportDocument.Import getImportArray(int i)
207        {
208            synchronized (monitor())
209            {
210                check_orphaned();
211                org.springframework.schema.beans.ImportDocument.Import target = null;
212                target = (org.springframework.schema.beans.ImportDocument.Import)get_store().find_element_user(IMPORT$2, i);
213                if (target == null)
214                {
215                    throw new IndexOutOfBoundsException();
216                }
217                return target;
218            }
219        }
220        
221        /**
222         * Returns number of "import" element
223         */
224        public int sizeOfImportArray()
225        {
226            synchronized (monitor())
227            {
228                check_orphaned();
229                return get_store().count_elements(IMPORT$2);
230            }
231        }
232        
233        /**
234         * Sets array of all "import" element
235         */
236        public void setImportArray(org.springframework.schema.beans.ImportDocument.Import[] ximportArray)
237        {
238            synchronized (monitor())
239            {
240                check_orphaned();
241                arraySetterHelper(ximportArray, IMPORT$2);
242            }
243        }
244        
245        /**
246         * Sets ith "import" element
247         */
248        public void setImportArray(int i, org.springframework.schema.beans.ImportDocument.Import ximport)
249        {
250            synchronized (monitor())
251            {
252                check_orphaned();
253                org.springframework.schema.beans.ImportDocument.Import target = null;
254                target = (org.springframework.schema.beans.ImportDocument.Import)get_store().find_element_user(IMPORT$2, i);
255                if (target == null)
256                {
257                    throw new IndexOutOfBoundsException();
258                }
259                target.set(ximport);
260            }
261        }
262        
263        /**
264         * Inserts and returns a new empty value (as xml) as the ith "import" element
265         */
266        public org.springframework.schema.beans.ImportDocument.Import insertNewImport(int i)
267        {
268            synchronized (monitor())
269            {
270                check_orphaned();
271                org.springframework.schema.beans.ImportDocument.Import target = null;
272                target = (org.springframework.schema.beans.ImportDocument.Import)get_store().insert_element_user(IMPORT$2, i);
273                return target;
274            }
275        }
276        
277        /**
278         * Appends and returns a new empty value (as xml) as the last "import" element
279         */
280        public org.springframework.schema.beans.ImportDocument.Import addNewImport()
281        {
282            synchronized (monitor())
283            {
284                check_orphaned();
285                org.springframework.schema.beans.ImportDocument.Import target = null;
286                target = (org.springframework.schema.beans.ImportDocument.Import)get_store().add_element_user(IMPORT$2);
287                return target;
288            }
289        }
290        
291        /**
292         * Removes the ith "import" element
293         */
294        public void removeImport(int i)
295        {
296            synchronized (monitor())
297            {
298                check_orphaned();
299                get_store().remove_element(IMPORT$2, i);
300            }
301        }
302        
303        /**
304         * Gets array of all "alias" elements
305         */
306        public org.springframework.schema.beans.AliasDocument.Alias[] getAliasArray()
307        {
308            synchronized (monitor())
309            {
310                check_orphaned();
311                java.util.List targetList = new java.util.ArrayList();
312                get_store().find_all_element_users(ALIAS$4, targetList);
313                org.springframework.schema.beans.AliasDocument.Alias[] result = new org.springframework.schema.beans.AliasDocument.Alias[targetList.size()];
314                targetList.toArray(result);
315                return result;
316            }
317        }
318        
319        /**
320         * Gets ith "alias" element
321         */
322        public org.springframework.schema.beans.AliasDocument.Alias getAliasArray(int i)
323        {
324            synchronized (monitor())
325            {
326                check_orphaned();
327                org.springframework.schema.beans.AliasDocument.Alias target = null;
328                target = (org.springframework.schema.beans.AliasDocument.Alias)get_store().find_element_user(ALIAS$4, i);
329                if (target == null)
330                {
331                    throw new IndexOutOfBoundsException();
332                }
333                return target;
334            }
335        }
336        
337        /**
338         * Returns number of "alias" element
339         */
340        public int sizeOfAliasArray()
341        {
342            synchronized (monitor())
343            {
344                check_orphaned();
345                return get_store().count_elements(ALIAS$4);
346            }
347        }
348        
349        /**
350         * Sets array of all "alias" element
351         */
352        public void setAliasArray(org.springframework.schema.beans.AliasDocument.Alias[] aliasArray)
353        {
354            synchronized (monitor())
355            {
356                check_orphaned();
357                arraySetterHelper(aliasArray, ALIAS$4);
358            }
359        }
360        
361        /**
362         * Sets ith "alias" element
363         */
364        public void setAliasArray(int i, org.springframework.schema.beans.AliasDocument.Alias alias)
365        {
366            synchronized (monitor())
367            {
368                check_orphaned();
369                org.springframework.schema.beans.AliasDocument.Alias target = null;
370                target = (org.springframework.schema.beans.AliasDocument.Alias)get_store().find_element_user(ALIAS$4, i);
371                if (target == null)
372                {
373                    throw new IndexOutOfBoundsException();
374                }
375                target.set(alias);
376            }
377        }
378        
379        /**
380         * Inserts and returns a new empty value (as xml) as the ith "alias" element
381         */
382        public org.springframework.schema.beans.AliasDocument.Alias insertNewAlias(int i)
383        {
384            synchronized (monitor())
385            {
386                check_orphaned();
387                org.springframework.schema.beans.AliasDocument.Alias target = null;
388                target = (org.springframework.schema.beans.AliasDocument.Alias)get_store().insert_element_user(ALIAS$4, i);
389                return target;
390            }
391        }
392        
393        /**
394         * Appends and returns a new empty value (as xml) as the last "alias" element
395         */
396        public org.springframework.schema.beans.AliasDocument.Alias addNewAlias()
397        {
398            synchronized (monitor())
399            {
400                check_orphaned();
401                org.springframework.schema.beans.AliasDocument.Alias target = null;
402                target = (org.springframework.schema.beans.AliasDocument.Alias)get_store().add_element_user(ALIAS$4);
403                return target;
404            }
405        }
406        
407        /**
408         * Removes the ith "alias" element
409         */
410        public void removeAlias(int i)
411        {
412            synchronized (monitor())
413            {
414                check_orphaned();
415                get_store().remove_element(ALIAS$4, i);
416            }
417        }
418        
419        /**
420         * Gets array of all "bean" elements
421         */
422        public org.springframework.schema.beans.BeanDocument.Bean[] getBeanArray()
423        {
424            synchronized (monitor())
425            {
426                check_orphaned();
427                java.util.List targetList = new java.util.ArrayList();
428                get_store().find_all_element_users(BEAN$6, targetList);
429                org.springframework.schema.beans.BeanDocument.Bean[] result = new org.springframework.schema.beans.BeanDocument.Bean[targetList.size()];
430                targetList.toArray(result);
431                return result;
432            }
433        }
434        
435        /**
436         * Gets ith "bean" element
437         */
438        public org.springframework.schema.beans.BeanDocument.Bean getBeanArray(int i)
439        {
440            synchronized (monitor())
441            {
442                check_orphaned();
443                org.springframework.schema.beans.BeanDocument.Bean target = null;
444                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$6, i);
445                if (target == null)
446                {
447                    throw new IndexOutOfBoundsException();
448                }
449                return target;
450            }
451        }
452        
453        /**
454         * Returns number of "bean" element
455         */
456        public int sizeOfBeanArray()
457        {
458            synchronized (monitor())
459            {
460                check_orphaned();
461                return get_store().count_elements(BEAN$6);
462            }
463        }
464        
465        /**
466         * Sets array of all "bean" element
467         */
468        public void setBeanArray(org.springframework.schema.beans.BeanDocument.Bean[] beanArray)
469        {
470            synchronized (monitor())
471            {
472                check_orphaned();
473                arraySetterHelper(beanArray, BEAN$6);
474            }
475        }
476        
477        /**
478         * Sets ith "bean" element
479         */
480        public void setBeanArray(int i, org.springframework.schema.beans.BeanDocument.Bean bean)
481        {
482            synchronized (monitor())
483            {
484                check_orphaned();
485                org.springframework.schema.beans.BeanDocument.Bean target = null;
486                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$6, i);
487                if (target == null)
488                {
489                    throw new IndexOutOfBoundsException();
490                }
491                target.set(bean);
492            }
493        }
494        
495        /**
496         * Inserts and returns a new empty value (as xml) as the ith "bean" element
497         */
498        public org.springframework.schema.beans.BeanDocument.Bean insertNewBean(int i)
499        {
500            synchronized (monitor())
501            {
502                check_orphaned();
503                org.springframework.schema.beans.BeanDocument.Bean target = null;
504                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().insert_element_user(BEAN$6, i);
505                return target;
506            }
507        }
508        
509        /**
510         * Appends and returns a new empty value (as xml) as the last "bean" element
511         */
512        public org.springframework.schema.beans.BeanDocument.Bean addNewBean()
513        {
514            synchronized (monitor())
515            {
516                check_orphaned();
517                org.springframework.schema.beans.BeanDocument.Bean target = null;
518                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$6);
519                return target;
520            }
521        }
522        
523        /**
524         * Removes the ith "bean" element
525         */
526        public void removeBean(int i)
527        {
528            synchronized (monitor())
529            {
530                check_orphaned();
531                get_store().remove_element(BEAN$6, i);
532            }
533        }
534        
535        /**
536         * Gets the "default-lazy-init" attribute
537         */
538        public boolean getDefaultLazyInit()
539        {
540            synchronized (monitor())
541            {
542                check_orphaned();
543                org.apache.xmlbeans.SimpleValue target = null;
544                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTLAZYINIT$8);
545                if (target == null)
546                {
547                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(DEFAULTLAZYINIT$8);
548                }
549                if (target == null)
550                {
551                    return false;
552                }
553                return target.getBooleanValue();
554            }
555        }
556        
557        /**
558         * Gets (as xml) the "default-lazy-init" attribute
559         */
560        public org.apache.xmlbeans.XmlBoolean xgetDefaultLazyInit()
561        {
562            synchronized (monitor())
563            {
564                check_orphaned();
565                org.apache.xmlbeans.XmlBoolean target = null;
566                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(DEFAULTLAZYINIT$8);
567                if (target == null)
568                {
569                    target = (org.apache.xmlbeans.XmlBoolean)get_default_attribute_value(DEFAULTLAZYINIT$8);
570                }
571                return target;
572            }
573        }
574        
575        /**
576         * True if has "default-lazy-init" attribute
577         */
578        public boolean isSetDefaultLazyInit()
579        {
580            synchronized (monitor())
581            {
582                check_orphaned();
583                return get_store().find_attribute_user(DEFAULTLAZYINIT$8) != null;
584            }
585        }
586        
587        /**
588         * Sets the "default-lazy-init" attribute
589         */
590        public void setDefaultLazyInit(boolean defaultLazyInit)
591        {
592            synchronized (monitor())
593            {
594                check_orphaned();
595                org.apache.xmlbeans.SimpleValue target = null;
596                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTLAZYINIT$8);
597                if (target == null)
598                {
599                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTLAZYINIT$8);
600                }
601                target.setBooleanValue(defaultLazyInit);
602            }
603        }
604        
605        /**
606         * Sets (as xml) the "default-lazy-init" attribute
607         */
608        public void xsetDefaultLazyInit(org.apache.xmlbeans.XmlBoolean defaultLazyInit)
609        {
610            synchronized (monitor())
611            {
612                check_orphaned();
613                org.apache.xmlbeans.XmlBoolean target = null;
614                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(DEFAULTLAZYINIT$8);
615                if (target == null)
616                {
617                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(DEFAULTLAZYINIT$8);
618                }
619                target.set(defaultLazyInit);
620            }
621        }
622        
623        /**
624         * Unsets the "default-lazy-init" attribute
625         */
626        public void unsetDefaultLazyInit()
627        {
628            synchronized (monitor())
629            {
630                check_orphaned();
631                get_store().remove_attribute(DEFAULTLAZYINIT$8);
632            }
633        }
634        
635        /**
636         * Gets the "default-merge" attribute
637         */
638        public boolean getDefaultMerge()
639        {
640            synchronized (monitor())
641            {
642                check_orphaned();
643                org.apache.xmlbeans.SimpleValue target = null;
644                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTMERGE$10);
645                if (target == null)
646                {
647                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(DEFAULTMERGE$10);
648                }
649                if (target == null)
650                {
651                    return false;
652                }
653                return target.getBooleanValue();
654            }
655        }
656        
657        /**
658         * Gets (as xml) the "default-merge" attribute
659         */
660        public org.apache.xmlbeans.XmlBoolean xgetDefaultMerge()
661        {
662            synchronized (monitor())
663            {
664                check_orphaned();
665                org.apache.xmlbeans.XmlBoolean target = null;
666                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(DEFAULTMERGE$10);
667                if (target == null)
668                {
669                    target = (org.apache.xmlbeans.XmlBoolean)get_default_attribute_value(DEFAULTMERGE$10);
670                }
671                return target;
672            }
673        }
674        
675        /**
676         * True if has "default-merge" attribute
677         */
678        public boolean isSetDefaultMerge()
679        {
680            synchronized (monitor())
681            {
682                check_orphaned();
683                return get_store().find_attribute_user(DEFAULTMERGE$10) != null;
684            }
685        }
686        
687        /**
688         * Sets the "default-merge" attribute
689         */
690        public void setDefaultMerge(boolean defaultMerge)
691        {
692            synchronized (monitor())
693            {
694                check_orphaned();
695                org.apache.xmlbeans.SimpleValue target = null;
696                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTMERGE$10);
697                if (target == null)
698                {
699                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTMERGE$10);
700                }
701                target.setBooleanValue(defaultMerge);
702            }
703        }
704        
705        /**
706         * Sets (as xml) the "default-merge" attribute
707         */
708        public void xsetDefaultMerge(org.apache.xmlbeans.XmlBoolean defaultMerge)
709        {
710            synchronized (monitor())
711            {
712                check_orphaned();
713                org.apache.xmlbeans.XmlBoolean target = null;
714                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(DEFAULTMERGE$10);
715                if (target == null)
716                {
717                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(DEFAULTMERGE$10);
718                }
719                target.set(defaultMerge);
720            }
721        }
722        
723        /**
724         * Unsets the "default-merge" attribute
725         */
726        public void unsetDefaultMerge()
727        {
728            synchronized (monitor())
729            {
730                check_orphaned();
731                get_store().remove_attribute(DEFAULTMERGE$10);
732            }
733        }
734        
735        /**
736         * Gets the "default-autowire" attribute
737         */
738        public org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire.Enum getDefaultAutowire()
739        {
740            synchronized (monitor())
741            {
742                check_orphaned();
743                org.apache.xmlbeans.SimpleValue target = null;
744                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTAUTOWIRE$12);
745                if (target == null)
746                {
747                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(DEFAULTAUTOWIRE$12);
748                }
749                if (target == null)
750                {
751                    return null;
752                }
753                return (org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire.Enum)target.getEnumValue();
754            }
755        }
756        
757        /**
758         * Gets (as xml) the "default-autowire" attribute
759         */
760        public org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire xgetDefaultAutowire()
761        {
762            synchronized (monitor())
763            {
764                check_orphaned();
765                org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire target = null;
766                target = (org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire)get_store().find_attribute_user(DEFAULTAUTOWIRE$12);
767                if (target == null)
768                {
769                    target = (org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire)get_default_attribute_value(DEFAULTAUTOWIRE$12);
770                }
771                return target;
772            }
773        }
774        
775        /**
776         * True if has "default-autowire" attribute
777         */
778        public boolean isSetDefaultAutowire()
779        {
780            synchronized (monitor())
781            {
782                check_orphaned();
783                return get_store().find_attribute_user(DEFAULTAUTOWIRE$12) != null;
784            }
785        }
786        
787        /**
788         * Sets the "default-autowire" attribute
789         */
790        public void setDefaultAutowire(org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire.Enum defaultAutowire)
791        {
792            synchronized (monitor())
793            {
794                check_orphaned();
795                org.apache.xmlbeans.SimpleValue target = null;
796                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTAUTOWIRE$12);
797                if (target == null)
798                {
799                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTAUTOWIRE$12);
800                }
801                target.setEnumValue(defaultAutowire);
802            }
803        }
804        
805        /**
806         * Sets (as xml) the "default-autowire" attribute
807         */
808        public void xsetDefaultAutowire(org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire defaultAutowire)
809        {
810            synchronized (monitor())
811            {
812                check_orphaned();
813                org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire target = null;
814                target = (org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire)get_store().find_attribute_user(DEFAULTAUTOWIRE$12);
815                if (target == null)
816                {
817                    target = (org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire)get_store().add_attribute_user(DEFAULTAUTOWIRE$12);
818                }
819                target.set(defaultAutowire);
820            }
821        }
822        
823        /**
824         * Unsets the "default-autowire" attribute
825         */
826        public void unsetDefaultAutowire()
827        {
828            synchronized (monitor())
829            {
830                check_orphaned();
831                get_store().remove_attribute(DEFAULTAUTOWIRE$12);
832            }
833        }
834        
835        /**
836         * Gets the "default-autowire-candidates" attribute
837         */
838        public java.lang.String getDefaultAutowireCandidates()
839        {
840            synchronized (monitor())
841            {
842                check_orphaned();
843                org.apache.xmlbeans.SimpleValue target = null;
844                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
845                if (target == null)
846                {
847                    return null;
848                }
849                return target.getStringValue();
850            }
851        }
852        
853        /**
854         * Gets (as xml) the "default-autowire-candidates" attribute
855         */
856        public org.apache.xmlbeans.XmlString xgetDefaultAutowireCandidates()
857        {
858            synchronized (monitor())
859            {
860                check_orphaned();
861                org.apache.xmlbeans.XmlString target = null;
862                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
863                return target;
864            }
865        }
866        
867        /**
868         * True if has "default-autowire-candidates" attribute
869         */
870        public boolean isSetDefaultAutowireCandidates()
871        {
872            synchronized (monitor())
873            {
874                check_orphaned();
875                return get_store().find_attribute_user(DEFAULTAUTOWIRECANDIDATES$14) != null;
876            }
877        }
878        
879        /**
880         * Sets the "default-autowire-candidates" attribute
881         */
882        public void setDefaultAutowireCandidates(java.lang.String defaultAutowireCandidates)
883        {
884            synchronized (monitor())
885            {
886                check_orphaned();
887                org.apache.xmlbeans.SimpleValue target = null;
888                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
889                if (target == null)
890                {
891                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
892                }
893                target.setStringValue(defaultAutowireCandidates);
894            }
895        }
896        
897        /**
898         * Sets (as xml) the "default-autowire-candidates" attribute
899         */
900        public void xsetDefaultAutowireCandidates(org.apache.xmlbeans.XmlString defaultAutowireCandidates)
901        {
902            synchronized (monitor())
903            {
904                check_orphaned();
905                org.apache.xmlbeans.XmlString target = null;
906                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
907                if (target == null)
908                {
909                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(DEFAULTAUTOWIRECANDIDATES$14);
910                }
911                target.set(defaultAutowireCandidates);
912            }
913        }
914        
915        /**
916         * Unsets the "default-autowire-candidates" attribute
917         */
918        public void unsetDefaultAutowireCandidates()
919        {
920            synchronized (monitor())
921            {
922                check_orphaned();
923                get_store().remove_attribute(DEFAULTAUTOWIRECANDIDATES$14);
924            }
925        }
926        
927        /**
928         * Gets the "default-init-method" attribute
929         */
930        public java.lang.String getDefaultInitMethod()
931        {
932            synchronized (monitor())
933            {
934                check_orphaned();
935                org.apache.xmlbeans.SimpleValue target = null;
936                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTINITMETHOD$16);
937                if (target == null)
938                {
939                    return null;
940                }
941                return target.getStringValue();
942            }
943        }
944        
945        /**
946         * Gets (as xml) the "default-init-method" attribute
947         */
948        public org.apache.xmlbeans.XmlString xgetDefaultInitMethod()
949        {
950            synchronized (monitor())
951            {
952                check_orphaned();
953                org.apache.xmlbeans.XmlString target = null;
954                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTINITMETHOD$16);
955                return target;
956            }
957        }
958        
959        /**
960         * True if has "default-init-method" attribute
961         */
962        public boolean isSetDefaultInitMethod()
963        {
964            synchronized (monitor())
965            {
966                check_orphaned();
967                return get_store().find_attribute_user(DEFAULTINITMETHOD$16) != null;
968            }
969        }
970        
971        /**
972         * Sets the "default-init-method" attribute
973         */
974        public void setDefaultInitMethod(java.lang.String defaultInitMethod)
975        {
976            synchronized (monitor())
977            {
978                check_orphaned();
979                org.apache.xmlbeans.SimpleValue target = null;
980                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTINITMETHOD$16);
981                if (target == null)
982                {
983                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTINITMETHOD$16);
984                }
985                target.setStringValue(defaultInitMethod);
986            }
987        }
988        
989        /**
990         * Sets (as xml) the "default-init-method" attribute
991         */
992        public void xsetDefaultInitMethod(org.apache.xmlbeans.XmlString defaultInitMethod)
993        {
994            synchronized (monitor())
995            {
996                check_orphaned();
997                org.apache.xmlbeans.XmlString target = null;
998                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTINITMETHOD$16);
999                if (target == null)
1000                {
1001                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(DEFAULTINITMETHOD$16);
1002                }
1003                target.set(defaultInitMethod);
1004            }
1005        }
1006        
1007        /**
1008         * Unsets the "default-init-method" attribute
1009         */
1010        public void unsetDefaultInitMethod()
1011        {
1012            synchronized (monitor())
1013            {
1014                check_orphaned();
1015                get_store().remove_attribute(DEFAULTINITMETHOD$16);
1016            }
1017        }
1018        
1019        /**
1020         * Gets the "default-destroy-method" attribute
1021         */
1022        public java.lang.String getDefaultDestroyMethod()
1023        {
1024            synchronized (monitor())
1025            {
1026                check_orphaned();
1027                org.apache.xmlbeans.SimpleValue target = null;
1028                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTDESTROYMETHOD$18);
1029                if (target == null)
1030                {
1031                    return null;
1032                }
1033                return target.getStringValue();
1034            }
1035        }
1036        
1037        /**
1038         * Gets (as xml) the "default-destroy-method" attribute
1039         */
1040        public org.apache.xmlbeans.XmlString xgetDefaultDestroyMethod()
1041        {
1042            synchronized (monitor())
1043            {
1044                check_orphaned();
1045                org.apache.xmlbeans.XmlString target = null;
1046                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTDESTROYMETHOD$18);
1047                return target;
1048            }
1049        }
1050        
1051        /**
1052         * True if has "default-destroy-method" attribute
1053         */
1054        public boolean isSetDefaultDestroyMethod()
1055        {
1056            synchronized (monitor())
1057            {
1058                check_orphaned();
1059                return get_store().find_attribute_user(DEFAULTDESTROYMETHOD$18) != null;
1060            }
1061        }
1062        
1063        /**
1064         * Sets the "default-destroy-method" attribute
1065         */
1066        public void setDefaultDestroyMethod(java.lang.String defaultDestroyMethod)
1067        {
1068            synchronized (monitor())
1069            {
1070                check_orphaned();
1071                org.apache.xmlbeans.SimpleValue target = null;
1072                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEFAULTDESTROYMETHOD$18);
1073                if (target == null)
1074                {
1075                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEFAULTDESTROYMETHOD$18);
1076                }
1077                target.setStringValue(defaultDestroyMethod);
1078            }
1079        }
1080        
1081        /**
1082         * Sets (as xml) the "default-destroy-method" attribute
1083         */
1084        public void xsetDefaultDestroyMethod(org.apache.xmlbeans.XmlString defaultDestroyMethod)
1085        {
1086            synchronized (monitor())
1087            {
1088                check_orphaned();
1089                org.apache.xmlbeans.XmlString target = null;
1090                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEFAULTDESTROYMETHOD$18);
1091                if (target == null)
1092                {
1093                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(DEFAULTDESTROYMETHOD$18);
1094                }
1095                target.set(defaultDestroyMethod);
1096            }
1097        }
1098        
1099        /**
1100         * Unsets the "default-destroy-method" attribute
1101         */
1102        public void unsetDefaultDestroyMethod()
1103        {
1104            synchronized (monitor())
1105            {
1106                check_orphaned();
1107                get_store().remove_attribute(DEFAULTDESTROYMETHOD$18);
1108            }
1109        }
1110        /**
1111         * An XML default-autowire(@).
1112         *
1113         * This is an atomic type that is a restriction of org.springframework.schema.beans.BeansDocument$Beans$DefaultAutowire.
1114         */
1115        public static class DefaultAutowireImpl extends org.apache.xmlbeans.impl.values.JavaStringEnumerationHolderEx implements org.springframework.schema.beans.BeansDocument.Beans.DefaultAutowire
1116        {
1117            private static final long serialVersionUID = 1L;
1118            
1119            public DefaultAutowireImpl(org.apache.xmlbeans.SchemaType sType)
1120            {
1121                super(sType, false);
1122            }
1123            
1124            protected DefaultAutowireImpl(org.apache.xmlbeans.SchemaType sType, boolean b)
1125            {
1126                super(sType, b);
1127            }
1128        }
1129    }
1130}