001/*
002 * An XML document type.
003 * Localname: bean
004 * Namespace: http://www.springframework.org/schema/beans
005 * Java type: org.springframework.schema.beans.BeanDocument
006 *
007 * Automatically generated - do not modify.
008 */
009package org.springframework.schema.beans.impl;
010/**
011 * A document containing one bean(@http://www.springframework.org/schema/beans) element.
012 *
013 * This is a complex type.
014 */
015public class BeanDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.BeanDocument
016{
017    private static final long serialVersionUID = 1L;
018    
019    public BeanDocumentImpl(org.apache.xmlbeans.SchemaType sType)
020    {
021        super(sType);
022    }
023    
024    private static final javax.xml.namespace.QName BEAN$0 = 
025        new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "bean");
026    
027    
028    /**
029     * Gets the "bean" element
030     */
031    public org.springframework.schema.beans.BeanDocument.Bean getBean()
032    {
033        synchronized (monitor())
034        {
035            check_orphaned();
036            org.springframework.schema.beans.BeanDocument.Bean target = null;
037            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$0, 0);
038            if (target == null)
039            {
040                return null;
041            }
042            return target;
043        }
044    }
045    
046    /**
047     * Sets the "bean" element
048     */
049    public void setBean(org.springframework.schema.beans.BeanDocument.Bean bean)
050    {
051        synchronized (monitor())
052        {
053            check_orphaned();
054            org.springframework.schema.beans.BeanDocument.Bean target = null;
055            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$0, 0);
056            if (target == null)
057            {
058                target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$0);
059            }
060            target.set(bean);
061        }
062    }
063    
064    /**
065     * Appends and returns a new empty "bean" element
066     */
067    public org.springframework.schema.beans.BeanDocument.Bean addNewBean()
068    {
069        synchronized (monitor())
070        {
071            check_orphaned();
072            org.springframework.schema.beans.BeanDocument.Bean target = null;
073            target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$0);
074            return target;
075        }
076    }
077    /**
078     * An XML bean(@http://www.springframework.org/schema/beans).
079     *
080     * This is a complex type.
081     */
082    public static class BeanImpl extends org.springframework.schema.beans.impl.IdentifiedTypeImpl implements org.springframework.schema.beans.BeanDocument.Bean
083    {
084        private static final long serialVersionUID = 1L;
085        
086        public BeanImpl(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 META$2 = 
094            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "meta");
095        private static final javax.xml.namespace.QName CONSTRUCTORARG$4 = 
096            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "constructor-arg");
097        private static final javax.xml.namespace.QName PROPERTY$6 = 
098            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "property");
099        private static final javax.xml.namespace.QName QUALIFIER$8 = 
100            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "qualifier");
101        private static final javax.xml.namespace.QName LOOKUPMETHOD$10 = 
102            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "lookup-method");
103        private static final javax.xml.namespace.QName REPLACEDMETHOD$12 = 
104            new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "replaced-method");
105        private static final javax.xml.namespace.QName NAME$14 = 
106            new javax.xml.namespace.QName("", "name");
107        private static final javax.xml.namespace.QName CLASS1$16 = 
108            new javax.xml.namespace.QName("", "class");
109        private static final javax.xml.namespace.QName PARENT$18 = 
110            new javax.xml.namespace.QName("", "parent");
111        private static final javax.xml.namespace.QName SCOPE$20 = 
112            new javax.xml.namespace.QName("", "scope");
113        private static final javax.xml.namespace.QName ABSTRACT$22 = 
114            new javax.xml.namespace.QName("", "abstract");
115        private static final javax.xml.namespace.QName LAZYINIT$24 = 
116            new javax.xml.namespace.QName("", "lazy-init");
117        private static final javax.xml.namespace.QName AUTOWIRE$26 = 
118            new javax.xml.namespace.QName("", "autowire");
119        private static final javax.xml.namespace.QName DEPENDSON$28 = 
120            new javax.xml.namespace.QName("", "depends-on");
121        private static final javax.xml.namespace.QName AUTOWIRECANDIDATE$30 = 
122            new javax.xml.namespace.QName("", "autowire-candidate");
123        private static final javax.xml.namespace.QName PRIMARY$32 = 
124            new javax.xml.namespace.QName("", "primary");
125        private static final javax.xml.namespace.QName INITMETHOD$34 = 
126            new javax.xml.namespace.QName("", "init-method");
127        private static final javax.xml.namespace.QName DESTROYMETHOD$36 = 
128            new javax.xml.namespace.QName("", "destroy-method");
129        private static final javax.xml.namespace.QName FACTORYMETHOD$38 = 
130            new javax.xml.namespace.QName("", "factory-method");
131        private static final javax.xml.namespace.QName FACTORYBEAN$40 = 
132            new javax.xml.namespace.QName("", "factory-bean");
133        
134        
135        /**
136         * Gets the "description" element
137         */
138        public org.springframework.schema.beans.DescriptionDocument.Description getDescription()
139        {
140            synchronized (monitor())
141            {
142                check_orphaned();
143                org.springframework.schema.beans.DescriptionDocument.Description target = null;
144                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
145                if (target == null)
146                {
147                    return null;
148                }
149                return target;
150            }
151        }
152        
153        /**
154         * True if has "description" element
155         */
156        public boolean isSetDescription()
157        {
158            synchronized (monitor())
159            {
160                check_orphaned();
161                return get_store().count_elements(DESCRIPTION$0) != 0;
162            }
163        }
164        
165        /**
166         * Sets the "description" element
167         */
168        public void setDescription(org.springframework.schema.beans.DescriptionDocument.Description description)
169        {
170            synchronized (monitor())
171            {
172                check_orphaned();
173                org.springframework.schema.beans.DescriptionDocument.Description target = null;
174                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$0, 0);
175                if (target == null)
176                {
177                    target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$0);
178                }
179                target.set(description);
180            }
181        }
182        
183        /**
184         * Appends and returns a new empty "description" element
185         */
186        public org.springframework.schema.beans.DescriptionDocument.Description addNewDescription()
187        {
188            synchronized (monitor())
189            {
190                check_orphaned();
191                org.springframework.schema.beans.DescriptionDocument.Description target = null;
192                target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$0);
193                return target;
194            }
195        }
196        
197        /**
198         * Unsets the "description" element
199         */
200        public void unsetDescription()
201        {
202            synchronized (monitor())
203            {
204                check_orphaned();
205                get_store().remove_element(DESCRIPTION$0, 0);
206            }
207        }
208        
209        /**
210         * Gets array of all "meta" elements
211         */
212        public org.springframework.schema.beans.MetaType[] getMetaArray()
213        {
214            synchronized (monitor())
215            {
216                check_orphaned();
217                java.util.List targetList = new java.util.ArrayList();
218                get_store().find_all_element_users(META$2, targetList);
219                org.springframework.schema.beans.MetaType[] result = new org.springframework.schema.beans.MetaType[targetList.size()];
220                targetList.toArray(result);
221                return result;
222            }
223        }
224        
225        /**
226         * Gets ith "meta" element
227         */
228        public org.springframework.schema.beans.MetaType getMetaArray(int i)
229        {
230            synchronized (monitor())
231            {
232                check_orphaned();
233                org.springframework.schema.beans.MetaType target = null;
234                target = (org.springframework.schema.beans.MetaType)get_store().find_element_user(META$2, i);
235                if (target == null)
236                {
237                    throw new IndexOutOfBoundsException();
238                }
239                return target;
240            }
241        }
242        
243        /**
244         * Returns number of "meta" element
245         */
246        public int sizeOfMetaArray()
247        {
248            synchronized (monitor())
249            {
250                check_orphaned();
251                return get_store().count_elements(META$2);
252            }
253        }
254        
255        /**
256         * Sets array of all "meta" element
257         */
258        public void setMetaArray(org.springframework.schema.beans.MetaType[] metaArray)
259        {
260            synchronized (monitor())
261            {
262                check_orphaned();
263                arraySetterHelper(metaArray, META$2);
264            }
265        }
266        
267        /**
268         * Sets ith "meta" element
269         */
270        public void setMetaArray(int i, org.springframework.schema.beans.MetaType meta)
271        {
272            synchronized (monitor())
273            {
274                check_orphaned();
275                org.springframework.schema.beans.MetaType target = null;
276                target = (org.springframework.schema.beans.MetaType)get_store().find_element_user(META$2, i);
277                if (target == null)
278                {
279                    throw new IndexOutOfBoundsException();
280                }
281                target.set(meta);
282            }
283        }
284        
285        /**
286         * Inserts and returns a new empty value (as xml) as the ith "meta" element
287         */
288        public org.springframework.schema.beans.MetaType insertNewMeta(int i)
289        {
290            synchronized (monitor())
291            {
292                check_orphaned();
293                org.springframework.schema.beans.MetaType target = null;
294                target = (org.springframework.schema.beans.MetaType)get_store().insert_element_user(META$2, i);
295                return target;
296            }
297        }
298        
299        /**
300         * Appends and returns a new empty value (as xml) as the last "meta" element
301         */
302        public org.springframework.schema.beans.MetaType addNewMeta()
303        {
304            synchronized (monitor())
305            {
306                check_orphaned();
307                org.springframework.schema.beans.MetaType target = null;
308                target = (org.springframework.schema.beans.MetaType)get_store().add_element_user(META$2);
309                return target;
310            }
311        }
312        
313        /**
314         * Removes the ith "meta" element
315         */
316        public void removeMeta(int i)
317        {
318            synchronized (monitor())
319            {
320                check_orphaned();
321                get_store().remove_element(META$2, i);
322            }
323        }
324        
325        /**
326         * Gets array of all "constructor-arg" elements
327         */
328        public org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg[] getConstructorArgArray()
329        {
330            synchronized (monitor())
331            {
332                check_orphaned();
333                java.util.List targetList = new java.util.ArrayList();
334                get_store().find_all_element_users(CONSTRUCTORARG$4, targetList);
335                org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg[] result = new org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg[targetList.size()];
336                targetList.toArray(result);
337                return result;
338            }
339        }
340        
341        /**
342         * Gets ith "constructor-arg" element
343         */
344        public org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg getConstructorArgArray(int i)
345        {
346            synchronized (monitor())
347            {
348                check_orphaned();
349                org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg target = null;
350                target = (org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg)get_store().find_element_user(CONSTRUCTORARG$4, i);
351                if (target == null)
352                {
353                    throw new IndexOutOfBoundsException();
354                }
355                return target;
356            }
357        }
358        
359        /**
360         * Returns number of "constructor-arg" element
361         */
362        public int sizeOfConstructorArgArray()
363        {
364            synchronized (monitor())
365            {
366                check_orphaned();
367                return get_store().count_elements(CONSTRUCTORARG$4);
368            }
369        }
370        
371        /**
372         * Sets array of all "constructor-arg" element
373         */
374        public void setConstructorArgArray(org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg[] constructorArgArray)
375        {
376            synchronized (monitor())
377            {
378                check_orphaned();
379                arraySetterHelper(constructorArgArray, CONSTRUCTORARG$4);
380            }
381        }
382        
383        /**
384         * Sets ith "constructor-arg" element
385         */
386        public void setConstructorArgArray(int i, org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg constructorArg)
387        {
388            synchronized (monitor())
389            {
390                check_orphaned();
391                org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg target = null;
392                target = (org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg)get_store().find_element_user(CONSTRUCTORARG$4, i);
393                if (target == null)
394                {
395                    throw new IndexOutOfBoundsException();
396                }
397                target.set(constructorArg);
398            }
399        }
400        
401        /**
402         * Inserts and returns a new empty value (as xml) as the ith "constructor-arg" element
403         */
404        public org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg insertNewConstructorArg(int i)
405        {
406            synchronized (monitor())
407            {
408                check_orphaned();
409                org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg target = null;
410                target = (org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg)get_store().insert_element_user(CONSTRUCTORARG$4, i);
411                return target;
412            }
413        }
414        
415        /**
416         * Appends and returns a new empty value (as xml) as the last "constructor-arg" element
417         */
418        public org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg addNewConstructorArg()
419        {
420            synchronized (monitor())
421            {
422                check_orphaned();
423                org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg target = null;
424                target = (org.springframework.schema.beans.ConstructorArgDocument.ConstructorArg)get_store().add_element_user(CONSTRUCTORARG$4);
425                return target;
426            }
427        }
428        
429        /**
430         * Removes the ith "constructor-arg" element
431         */
432        public void removeConstructorArg(int i)
433        {
434            synchronized (monitor())
435            {
436                check_orphaned();
437                get_store().remove_element(CONSTRUCTORARG$4, i);
438            }
439        }
440        
441        /**
442         * Gets array of all "property" elements
443         */
444        public org.springframework.schema.beans.PropertyType[] getPropertyArray()
445        {
446            synchronized (monitor())
447            {
448                check_orphaned();
449                java.util.List targetList = new java.util.ArrayList();
450                get_store().find_all_element_users(PROPERTY$6, targetList);
451                org.springframework.schema.beans.PropertyType[] result = new org.springframework.schema.beans.PropertyType[targetList.size()];
452                targetList.toArray(result);
453                return result;
454            }
455        }
456        
457        /**
458         * Gets ith "property" element
459         */
460        public org.springframework.schema.beans.PropertyType getPropertyArray(int i)
461        {
462            synchronized (monitor())
463            {
464                check_orphaned();
465                org.springframework.schema.beans.PropertyType target = null;
466                target = (org.springframework.schema.beans.PropertyType)get_store().find_element_user(PROPERTY$6, i);
467                if (target == null)
468                {
469                    throw new IndexOutOfBoundsException();
470                }
471                return target;
472            }
473        }
474        
475        /**
476         * Returns number of "property" element
477         */
478        public int sizeOfPropertyArray()
479        {
480            synchronized (monitor())
481            {
482                check_orphaned();
483                return get_store().count_elements(PROPERTY$6);
484            }
485        }
486        
487        /**
488         * Sets array of all "property" element
489         */
490        public void setPropertyArray(org.springframework.schema.beans.PropertyType[] propertyArray)
491        {
492            synchronized (monitor())
493            {
494                check_orphaned();
495                arraySetterHelper(propertyArray, PROPERTY$6);
496            }
497        }
498        
499        /**
500         * Sets ith "property" element
501         */
502        public void setPropertyArray(int i, org.springframework.schema.beans.PropertyType property)
503        {
504            synchronized (monitor())
505            {
506                check_orphaned();
507                org.springframework.schema.beans.PropertyType target = null;
508                target = (org.springframework.schema.beans.PropertyType)get_store().find_element_user(PROPERTY$6, i);
509                if (target == null)
510                {
511                    throw new IndexOutOfBoundsException();
512                }
513                target.set(property);
514            }
515        }
516        
517        /**
518         * Inserts and returns a new empty value (as xml) as the ith "property" element
519         */
520        public org.springframework.schema.beans.PropertyType insertNewProperty(int i)
521        {
522            synchronized (monitor())
523            {
524                check_orphaned();
525                org.springframework.schema.beans.PropertyType target = null;
526                target = (org.springframework.schema.beans.PropertyType)get_store().insert_element_user(PROPERTY$6, i);
527                return target;
528            }
529        }
530        
531        /**
532         * Appends and returns a new empty value (as xml) as the last "property" element
533         */
534        public org.springframework.schema.beans.PropertyType addNewProperty()
535        {
536            synchronized (monitor())
537            {
538                check_orphaned();
539                org.springframework.schema.beans.PropertyType target = null;
540                target = (org.springframework.schema.beans.PropertyType)get_store().add_element_user(PROPERTY$6);
541                return target;
542            }
543        }
544        
545        /**
546         * Removes the ith "property" element
547         */
548        public void removeProperty(int i)
549        {
550            synchronized (monitor())
551            {
552                check_orphaned();
553                get_store().remove_element(PROPERTY$6, i);
554            }
555        }
556        
557        /**
558         * Gets array of all "qualifier" elements
559         */
560        public org.springframework.schema.beans.QualifierDocument.Qualifier[] getQualifierArray()
561        {
562            synchronized (monitor())
563            {
564                check_orphaned();
565                java.util.List targetList = new java.util.ArrayList();
566                get_store().find_all_element_users(QUALIFIER$8, targetList);
567                org.springframework.schema.beans.QualifierDocument.Qualifier[] result = new org.springframework.schema.beans.QualifierDocument.Qualifier[targetList.size()];
568                targetList.toArray(result);
569                return result;
570            }
571        }
572        
573        /**
574         * Gets ith "qualifier" element
575         */
576        public org.springframework.schema.beans.QualifierDocument.Qualifier getQualifierArray(int i)
577        {
578            synchronized (monitor())
579            {
580                check_orphaned();
581                org.springframework.schema.beans.QualifierDocument.Qualifier target = null;
582                target = (org.springframework.schema.beans.QualifierDocument.Qualifier)get_store().find_element_user(QUALIFIER$8, i);
583                if (target == null)
584                {
585                    throw new IndexOutOfBoundsException();
586                }
587                return target;
588            }
589        }
590        
591        /**
592         * Returns number of "qualifier" element
593         */
594        public int sizeOfQualifierArray()
595        {
596            synchronized (monitor())
597            {
598                check_orphaned();
599                return get_store().count_elements(QUALIFIER$8);
600            }
601        }
602        
603        /**
604         * Sets array of all "qualifier" element
605         */
606        public void setQualifierArray(org.springframework.schema.beans.QualifierDocument.Qualifier[] qualifierArray)
607        {
608            synchronized (monitor())
609            {
610                check_orphaned();
611                arraySetterHelper(qualifierArray, QUALIFIER$8);
612            }
613        }
614        
615        /**
616         * Sets ith "qualifier" element
617         */
618        public void setQualifierArray(int i, org.springframework.schema.beans.QualifierDocument.Qualifier qualifier)
619        {
620            synchronized (monitor())
621            {
622                check_orphaned();
623                org.springframework.schema.beans.QualifierDocument.Qualifier target = null;
624                target = (org.springframework.schema.beans.QualifierDocument.Qualifier)get_store().find_element_user(QUALIFIER$8, i);
625                if (target == null)
626                {
627                    throw new IndexOutOfBoundsException();
628                }
629                target.set(qualifier);
630            }
631        }
632        
633        /**
634         * Inserts and returns a new empty value (as xml) as the ith "qualifier" element
635         */
636        public org.springframework.schema.beans.QualifierDocument.Qualifier insertNewQualifier(int i)
637        {
638            synchronized (monitor())
639            {
640                check_orphaned();
641                org.springframework.schema.beans.QualifierDocument.Qualifier target = null;
642                target = (org.springframework.schema.beans.QualifierDocument.Qualifier)get_store().insert_element_user(QUALIFIER$8, i);
643                return target;
644            }
645        }
646        
647        /**
648         * Appends and returns a new empty value (as xml) as the last "qualifier" element
649         */
650        public org.springframework.schema.beans.QualifierDocument.Qualifier addNewQualifier()
651        {
652            synchronized (monitor())
653            {
654                check_orphaned();
655                org.springframework.schema.beans.QualifierDocument.Qualifier target = null;
656                target = (org.springframework.schema.beans.QualifierDocument.Qualifier)get_store().add_element_user(QUALIFIER$8);
657                return target;
658            }
659        }
660        
661        /**
662         * Removes the ith "qualifier" element
663         */
664        public void removeQualifier(int i)
665        {
666            synchronized (monitor())
667            {
668                check_orphaned();
669                get_store().remove_element(QUALIFIER$8, i);
670            }
671        }
672        
673        /**
674         * Gets array of all "lookup-method" elements
675         */
676        public org.springframework.schema.beans.LookupMethodDocument.LookupMethod[] getLookupMethodArray()
677        {
678            synchronized (monitor())
679            {
680                check_orphaned();
681                java.util.List targetList = new java.util.ArrayList();
682                get_store().find_all_element_users(LOOKUPMETHOD$10, targetList);
683                org.springframework.schema.beans.LookupMethodDocument.LookupMethod[] result = new org.springframework.schema.beans.LookupMethodDocument.LookupMethod[targetList.size()];
684                targetList.toArray(result);
685                return result;
686            }
687        }
688        
689        /**
690         * Gets ith "lookup-method" element
691         */
692        public org.springframework.schema.beans.LookupMethodDocument.LookupMethod getLookupMethodArray(int i)
693        {
694            synchronized (monitor())
695            {
696                check_orphaned();
697                org.springframework.schema.beans.LookupMethodDocument.LookupMethod target = null;
698                target = (org.springframework.schema.beans.LookupMethodDocument.LookupMethod)get_store().find_element_user(LOOKUPMETHOD$10, i);
699                if (target == null)
700                {
701                    throw new IndexOutOfBoundsException();
702                }
703                return target;
704            }
705        }
706        
707        /**
708         * Returns number of "lookup-method" element
709         */
710        public int sizeOfLookupMethodArray()
711        {
712            synchronized (monitor())
713            {
714                check_orphaned();
715                return get_store().count_elements(LOOKUPMETHOD$10);
716            }
717        }
718        
719        /**
720         * Sets array of all "lookup-method" element
721         */
722        public void setLookupMethodArray(org.springframework.schema.beans.LookupMethodDocument.LookupMethod[] lookupMethodArray)
723        {
724            synchronized (monitor())
725            {
726                check_orphaned();
727                arraySetterHelper(lookupMethodArray, LOOKUPMETHOD$10);
728            }
729        }
730        
731        /**
732         * Sets ith "lookup-method" element
733         */
734        public void setLookupMethodArray(int i, org.springframework.schema.beans.LookupMethodDocument.LookupMethod lookupMethod)
735        {
736            synchronized (monitor())
737            {
738                check_orphaned();
739                org.springframework.schema.beans.LookupMethodDocument.LookupMethod target = null;
740                target = (org.springframework.schema.beans.LookupMethodDocument.LookupMethod)get_store().find_element_user(LOOKUPMETHOD$10, i);
741                if (target == null)
742                {
743                    throw new IndexOutOfBoundsException();
744                }
745                target.set(lookupMethod);
746            }
747        }
748        
749        /**
750         * Inserts and returns a new empty value (as xml) as the ith "lookup-method" element
751         */
752        public org.springframework.schema.beans.LookupMethodDocument.LookupMethod insertNewLookupMethod(int i)
753        {
754            synchronized (monitor())
755            {
756                check_orphaned();
757                org.springframework.schema.beans.LookupMethodDocument.LookupMethod target = null;
758                target = (org.springframework.schema.beans.LookupMethodDocument.LookupMethod)get_store().insert_element_user(LOOKUPMETHOD$10, i);
759                return target;
760            }
761        }
762        
763        /**
764         * Appends and returns a new empty value (as xml) as the last "lookup-method" element
765         */
766        public org.springframework.schema.beans.LookupMethodDocument.LookupMethod addNewLookupMethod()
767        {
768            synchronized (monitor())
769            {
770                check_orphaned();
771                org.springframework.schema.beans.LookupMethodDocument.LookupMethod target = null;
772                target = (org.springframework.schema.beans.LookupMethodDocument.LookupMethod)get_store().add_element_user(LOOKUPMETHOD$10);
773                return target;
774            }
775        }
776        
777        /**
778         * Removes the ith "lookup-method" element
779         */
780        public void removeLookupMethod(int i)
781        {
782            synchronized (monitor())
783            {
784                check_orphaned();
785                get_store().remove_element(LOOKUPMETHOD$10, i);
786            }
787        }
788        
789        /**
790         * Gets array of all "replaced-method" elements
791         */
792        public org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod[] getReplacedMethodArray()
793        {
794            synchronized (monitor())
795            {
796                check_orphaned();
797                java.util.List targetList = new java.util.ArrayList();
798                get_store().find_all_element_users(REPLACEDMETHOD$12, targetList);
799                org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod[] result = new org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod[targetList.size()];
800                targetList.toArray(result);
801                return result;
802            }
803        }
804        
805        /**
806         * Gets ith "replaced-method" element
807         */
808        public org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod getReplacedMethodArray(int i)
809        {
810            synchronized (monitor())
811            {
812                check_orphaned();
813                org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod target = null;
814                target = (org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod)get_store().find_element_user(REPLACEDMETHOD$12, i);
815                if (target == null)
816                {
817                    throw new IndexOutOfBoundsException();
818                }
819                return target;
820            }
821        }
822        
823        /**
824         * Returns number of "replaced-method" element
825         */
826        public int sizeOfReplacedMethodArray()
827        {
828            synchronized (monitor())
829            {
830                check_orphaned();
831                return get_store().count_elements(REPLACEDMETHOD$12);
832            }
833        }
834        
835        /**
836         * Sets array of all "replaced-method" element
837         */
838        public void setReplacedMethodArray(org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod[] replacedMethodArray)
839        {
840            synchronized (monitor())
841            {
842                check_orphaned();
843                arraySetterHelper(replacedMethodArray, REPLACEDMETHOD$12);
844            }
845        }
846        
847        /**
848         * Sets ith "replaced-method" element
849         */
850        public void setReplacedMethodArray(int i, org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod replacedMethod)
851        {
852            synchronized (monitor())
853            {
854                check_orphaned();
855                org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod target = null;
856                target = (org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod)get_store().find_element_user(REPLACEDMETHOD$12, i);
857                if (target == null)
858                {
859                    throw new IndexOutOfBoundsException();
860                }
861                target.set(replacedMethod);
862            }
863        }
864        
865        /**
866         * Inserts and returns a new empty value (as xml) as the ith "replaced-method" element
867         */
868        public org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod insertNewReplacedMethod(int i)
869        {
870            synchronized (monitor())
871            {
872                check_orphaned();
873                org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod target = null;
874                target = (org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod)get_store().insert_element_user(REPLACEDMETHOD$12, i);
875                return target;
876            }
877        }
878        
879        /**
880         * Appends and returns a new empty value (as xml) as the last "replaced-method" element
881         */
882        public org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod addNewReplacedMethod()
883        {
884            synchronized (monitor())
885            {
886                check_orphaned();
887                org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod target = null;
888                target = (org.springframework.schema.beans.ReplacedMethodDocument.ReplacedMethod)get_store().add_element_user(REPLACEDMETHOD$12);
889                return target;
890            }
891        }
892        
893        /**
894         * Removes the ith "replaced-method" element
895         */
896        public void removeReplacedMethod(int i)
897        {
898            synchronized (monitor())
899            {
900                check_orphaned();
901                get_store().remove_element(REPLACEDMETHOD$12, i);
902            }
903        }
904        
905        /**
906         * Gets the "name" attribute
907         */
908        public java.lang.String getName()
909        {
910            synchronized (monitor())
911            {
912                check_orphaned();
913                org.apache.xmlbeans.SimpleValue target = null;
914                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$14);
915                if (target == null)
916                {
917                    return null;
918                }
919                return target.getStringValue();
920            }
921        }
922        
923        /**
924         * Gets (as xml) the "name" attribute
925         */
926        public org.apache.xmlbeans.XmlString xgetName()
927        {
928            synchronized (monitor())
929            {
930                check_orphaned();
931                org.apache.xmlbeans.XmlString target = null;
932                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(NAME$14);
933                return target;
934            }
935        }
936        
937        /**
938         * True if has "name" attribute
939         */
940        public boolean isSetName()
941        {
942            synchronized (monitor())
943            {
944                check_orphaned();
945                return get_store().find_attribute_user(NAME$14) != null;
946            }
947        }
948        
949        /**
950         * Sets the "name" attribute
951         */
952        public void setName(java.lang.String name)
953        {
954            synchronized (monitor())
955            {
956                check_orphaned();
957                org.apache.xmlbeans.SimpleValue target = null;
958                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$14);
959                if (target == null)
960                {
961                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$14);
962                }
963                target.setStringValue(name);
964            }
965        }
966        
967        /**
968         * Sets (as xml) the "name" attribute
969         */
970        public void xsetName(org.apache.xmlbeans.XmlString name)
971        {
972            synchronized (monitor())
973            {
974                check_orphaned();
975                org.apache.xmlbeans.XmlString target = null;
976                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(NAME$14);
977                if (target == null)
978                {
979                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(NAME$14);
980                }
981                target.set(name);
982            }
983        }
984        
985        /**
986         * Unsets the "name" attribute
987         */
988        public void unsetName()
989        {
990            synchronized (monitor())
991            {
992                check_orphaned();
993                get_store().remove_attribute(NAME$14);
994            }
995        }
996        
997        /**
998         * Gets the "class" attribute
999         */
1000        public java.lang.String getClass1()
1001        {
1002            synchronized (monitor())
1003            {
1004                check_orphaned();
1005                org.apache.xmlbeans.SimpleValue target = null;
1006                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(CLASS1$16);
1007                if (target == null)
1008                {
1009                    return null;
1010                }
1011                return target.getStringValue();
1012            }
1013        }
1014        
1015        /**
1016         * Gets (as xml) the "class" attribute
1017         */
1018        public org.apache.xmlbeans.XmlString xgetClass1()
1019        {
1020            synchronized (monitor())
1021            {
1022                check_orphaned();
1023                org.apache.xmlbeans.XmlString target = null;
1024                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(CLASS1$16);
1025                return target;
1026            }
1027        }
1028        
1029        /**
1030         * True if has "class" attribute
1031         */
1032        public boolean isSetClass1()
1033        {
1034            synchronized (monitor())
1035            {
1036                check_orphaned();
1037                return get_store().find_attribute_user(CLASS1$16) != null;
1038            }
1039        }
1040        
1041        /**
1042         * Sets the "class" attribute
1043         */
1044        public void setClass1(java.lang.String class1)
1045        {
1046            synchronized (monitor())
1047            {
1048                check_orphaned();
1049                org.apache.xmlbeans.SimpleValue target = null;
1050                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(CLASS1$16);
1051                if (target == null)
1052                {
1053                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(CLASS1$16);
1054                }
1055                target.setStringValue(class1);
1056            }
1057        }
1058        
1059        /**
1060         * Sets (as xml) the "class" attribute
1061         */
1062        public void xsetClass1(org.apache.xmlbeans.XmlString class1)
1063        {
1064            synchronized (monitor())
1065            {
1066                check_orphaned();
1067                org.apache.xmlbeans.XmlString target = null;
1068                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(CLASS1$16);
1069                if (target == null)
1070                {
1071                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(CLASS1$16);
1072                }
1073                target.set(class1);
1074            }
1075        }
1076        
1077        /**
1078         * Unsets the "class" attribute
1079         */
1080        public void unsetClass1()
1081        {
1082            synchronized (monitor())
1083            {
1084                check_orphaned();
1085                get_store().remove_attribute(CLASS1$16);
1086            }
1087        }
1088        
1089        /**
1090         * Gets the "parent" attribute
1091         */
1092        public java.lang.String getParent()
1093        {
1094            synchronized (monitor())
1095            {
1096                check_orphaned();
1097                org.apache.xmlbeans.SimpleValue target = null;
1098                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PARENT$18);
1099                if (target == null)
1100                {
1101                    return null;
1102                }
1103                return target.getStringValue();
1104            }
1105        }
1106        
1107        /**
1108         * Gets (as xml) the "parent" attribute
1109         */
1110        public org.apache.xmlbeans.XmlString xgetParent()
1111        {
1112            synchronized (monitor())
1113            {
1114                check_orphaned();
1115                org.apache.xmlbeans.XmlString target = null;
1116                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(PARENT$18);
1117                return target;
1118            }
1119        }
1120        
1121        /**
1122         * True if has "parent" attribute
1123         */
1124        public boolean isSetParent()
1125        {
1126            synchronized (monitor())
1127            {
1128                check_orphaned();
1129                return get_store().find_attribute_user(PARENT$18) != null;
1130            }
1131        }
1132        
1133        /**
1134         * Sets the "parent" attribute
1135         */
1136        public void setParent(java.lang.String parent)
1137        {
1138            synchronized (monitor())
1139            {
1140                check_orphaned();
1141                org.apache.xmlbeans.SimpleValue target = null;
1142                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PARENT$18);
1143                if (target == null)
1144                {
1145                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(PARENT$18);
1146                }
1147                target.setStringValue(parent);
1148            }
1149        }
1150        
1151        /**
1152         * Sets (as xml) the "parent" attribute
1153         */
1154        public void xsetParent(org.apache.xmlbeans.XmlString parent)
1155        {
1156            synchronized (monitor())
1157            {
1158                check_orphaned();
1159                org.apache.xmlbeans.XmlString target = null;
1160                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(PARENT$18);
1161                if (target == null)
1162                {
1163                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(PARENT$18);
1164                }
1165                target.set(parent);
1166            }
1167        }
1168        
1169        /**
1170         * Unsets the "parent" attribute
1171         */
1172        public void unsetParent()
1173        {
1174            synchronized (monitor())
1175            {
1176                check_orphaned();
1177                get_store().remove_attribute(PARENT$18);
1178            }
1179        }
1180        
1181        /**
1182         * Gets the "scope" attribute
1183         */
1184        public java.lang.String getScope()
1185        {
1186            synchronized (monitor())
1187            {
1188                check_orphaned();
1189                org.apache.xmlbeans.SimpleValue target = null;
1190                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SCOPE$20);
1191                if (target == null)
1192                {
1193                    return null;
1194                }
1195                return target.getStringValue();
1196            }
1197        }
1198        
1199        /**
1200         * Gets (as xml) the "scope" attribute
1201         */
1202        public org.apache.xmlbeans.XmlString xgetScope()
1203        {
1204            synchronized (monitor())
1205            {
1206                check_orphaned();
1207                org.apache.xmlbeans.XmlString target = null;
1208                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SCOPE$20);
1209                return target;
1210            }
1211        }
1212        
1213        /**
1214         * True if has "scope" attribute
1215         */
1216        public boolean isSetScope()
1217        {
1218            synchronized (monitor())
1219            {
1220                check_orphaned();
1221                return get_store().find_attribute_user(SCOPE$20) != null;
1222            }
1223        }
1224        
1225        /**
1226         * Sets the "scope" attribute
1227         */
1228        public void setScope(java.lang.String scope)
1229        {
1230            synchronized (monitor())
1231            {
1232                check_orphaned();
1233                org.apache.xmlbeans.SimpleValue target = null;
1234                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SCOPE$20);
1235                if (target == null)
1236                {
1237                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SCOPE$20);
1238                }
1239                target.setStringValue(scope);
1240            }
1241        }
1242        
1243        /**
1244         * Sets (as xml) the "scope" attribute
1245         */
1246        public void xsetScope(org.apache.xmlbeans.XmlString scope)
1247        {
1248            synchronized (monitor())
1249            {
1250                check_orphaned();
1251                org.apache.xmlbeans.XmlString target = null;
1252                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SCOPE$20);
1253                if (target == null)
1254                {
1255                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(SCOPE$20);
1256                }
1257                target.set(scope);
1258            }
1259        }
1260        
1261        /**
1262         * Unsets the "scope" attribute
1263         */
1264        public void unsetScope()
1265        {
1266            synchronized (monitor())
1267            {
1268                check_orphaned();
1269                get_store().remove_attribute(SCOPE$20);
1270            }
1271        }
1272        
1273        /**
1274         * Gets the "abstract" attribute
1275         */
1276        public boolean getAbstract()
1277        {
1278            synchronized (monitor())
1279            {
1280                check_orphaned();
1281                org.apache.xmlbeans.SimpleValue target = null;
1282                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ABSTRACT$22);
1283                if (target == null)
1284                {
1285                    return false;
1286                }
1287                return target.getBooleanValue();
1288            }
1289        }
1290        
1291        /**
1292         * Gets (as xml) the "abstract" attribute
1293         */
1294        public org.apache.xmlbeans.XmlBoolean xgetAbstract()
1295        {
1296            synchronized (monitor())
1297            {
1298                check_orphaned();
1299                org.apache.xmlbeans.XmlBoolean target = null;
1300                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ABSTRACT$22);
1301                return target;
1302            }
1303        }
1304        
1305        /**
1306         * True if has "abstract" attribute
1307         */
1308        public boolean isSetAbstract()
1309        {
1310            synchronized (monitor())
1311            {
1312                check_orphaned();
1313                return get_store().find_attribute_user(ABSTRACT$22) != null;
1314            }
1315        }
1316        
1317        /**
1318         * Sets the "abstract" attribute
1319         */
1320        public void setAbstract(boolean xabstract)
1321        {
1322            synchronized (monitor())
1323            {
1324                check_orphaned();
1325                org.apache.xmlbeans.SimpleValue target = null;
1326                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ABSTRACT$22);
1327                if (target == null)
1328                {
1329                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ABSTRACT$22);
1330                }
1331                target.setBooleanValue(xabstract);
1332            }
1333        }
1334        
1335        /**
1336         * Sets (as xml) the "abstract" attribute
1337         */
1338        public void xsetAbstract(org.apache.xmlbeans.XmlBoolean xabstract)
1339        {
1340            synchronized (monitor())
1341            {
1342                check_orphaned();
1343                org.apache.xmlbeans.XmlBoolean target = null;
1344                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ABSTRACT$22);
1345                if (target == null)
1346                {
1347                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(ABSTRACT$22);
1348                }
1349                target.set(xabstract);
1350            }
1351        }
1352        
1353        /**
1354         * Unsets the "abstract" attribute
1355         */
1356        public void unsetAbstract()
1357        {
1358            synchronized (monitor())
1359            {
1360                check_orphaned();
1361                get_store().remove_attribute(ABSTRACT$22);
1362            }
1363        }
1364        
1365        /**
1366         * Gets the "lazy-init" attribute
1367         */
1368        public org.springframework.schema.beans.DefaultableBoolean.Enum getLazyInit()
1369        {
1370            synchronized (monitor())
1371            {
1372                check_orphaned();
1373                org.apache.xmlbeans.SimpleValue target = null;
1374                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LAZYINIT$24);
1375                if (target == null)
1376                {
1377                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(LAZYINIT$24);
1378                }
1379                if (target == null)
1380                {
1381                    return null;
1382                }
1383                return (org.springframework.schema.beans.DefaultableBoolean.Enum)target.getEnumValue();
1384            }
1385        }
1386        
1387        /**
1388         * Gets (as xml) the "lazy-init" attribute
1389         */
1390        public org.springframework.schema.beans.DefaultableBoolean xgetLazyInit()
1391        {
1392            synchronized (monitor())
1393            {
1394                check_orphaned();
1395                org.springframework.schema.beans.DefaultableBoolean target = null;
1396                target = (org.springframework.schema.beans.DefaultableBoolean)get_store().find_attribute_user(LAZYINIT$24);
1397                if (target == null)
1398                {
1399                    target = (org.springframework.schema.beans.DefaultableBoolean)get_default_attribute_value(LAZYINIT$24);
1400                }
1401                return target;
1402            }
1403        }
1404        
1405        /**
1406         * True if has "lazy-init" attribute
1407         */
1408        public boolean isSetLazyInit()
1409        {
1410            synchronized (monitor())
1411            {
1412                check_orphaned();
1413                return get_store().find_attribute_user(LAZYINIT$24) != null;
1414            }
1415        }
1416        
1417        /**
1418         * Sets the "lazy-init" attribute
1419         */
1420        public void setLazyInit(org.springframework.schema.beans.DefaultableBoolean.Enum lazyInit)
1421        {
1422            synchronized (monitor())
1423            {
1424                check_orphaned();
1425                org.apache.xmlbeans.SimpleValue target = null;
1426                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(LAZYINIT$24);
1427                if (target == null)
1428                {
1429                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(LAZYINIT$24);
1430                }
1431                target.setEnumValue(lazyInit);
1432            }
1433        }
1434        
1435        /**
1436         * Sets (as xml) the "lazy-init" attribute
1437         */
1438        public void xsetLazyInit(org.springframework.schema.beans.DefaultableBoolean lazyInit)
1439        {
1440            synchronized (monitor())
1441            {
1442                check_orphaned();
1443                org.springframework.schema.beans.DefaultableBoolean target = null;
1444                target = (org.springframework.schema.beans.DefaultableBoolean)get_store().find_attribute_user(LAZYINIT$24);
1445                if (target == null)
1446                {
1447                    target = (org.springframework.schema.beans.DefaultableBoolean)get_store().add_attribute_user(LAZYINIT$24);
1448                }
1449                target.set(lazyInit);
1450            }
1451        }
1452        
1453        /**
1454         * Unsets the "lazy-init" attribute
1455         */
1456        public void unsetLazyInit()
1457        {
1458            synchronized (monitor())
1459            {
1460                check_orphaned();
1461                get_store().remove_attribute(LAZYINIT$24);
1462            }
1463        }
1464        
1465        /**
1466         * Gets the "autowire" attribute
1467         */
1468        public org.springframework.schema.beans.BeanDocument.Bean.Autowire.Enum getAutowire()
1469        {
1470            synchronized (monitor())
1471            {
1472                check_orphaned();
1473                org.apache.xmlbeans.SimpleValue target = null;
1474                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(AUTOWIRE$26);
1475                if (target == null)
1476                {
1477                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(AUTOWIRE$26);
1478                }
1479                if (target == null)
1480                {
1481                    return null;
1482                }
1483                return (org.springframework.schema.beans.BeanDocument.Bean.Autowire.Enum)target.getEnumValue();
1484            }
1485        }
1486        
1487        /**
1488         * Gets (as xml) the "autowire" attribute
1489         */
1490        public org.springframework.schema.beans.BeanDocument.Bean.Autowire xgetAutowire()
1491        {
1492            synchronized (monitor())
1493            {
1494                check_orphaned();
1495                org.springframework.schema.beans.BeanDocument.Bean.Autowire target = null;
1496                target = (org.springframework.schema.beans.BeanDocument.Bean.Autowire)get_store().find_attribute_user(AUTOWIRE$26);
1497                if (target == null)
1498                {
1499                    target = (org.springframework.schema.beans.BeanDocument.Bean.Autowire)get_default_attribute_value(AUTOWIRE$26);
1500                }
1501                return target;
1502            }
1503        }
1504        
1505        /**
1506         * True if has "autowire" attribute
1507         */
1508        public boolean isSetAutowire()
1509        {
1510            synchronized (monitor())
1511            {
1512                check_orphaned();
1513                return get_store().find_attribute_user(AUTOWIRE$26) != null;
1514            }
1515        }
1516        
1517        /**
1518         * Sets the "autowire" attribute
1519         */
1520        public void setAutowire(org.springframework.schema.beans.BeanDocument.Bean.Autowire.Enum autowire)
1521        {
1522            synchronized (monitor())
1523            {
1524                check_orphaned();
1525                org.apache.xmlbeans.SimpleValue target = null;
1526                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(AUTOWIRE$26);
1527                if (target == null)
1528                {
1529                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(AUTOWIRE$26);
1530                }
1531                target.setEnumValue(autowire);
1532            }
1533        }
1534        
1535        /**
1536         * Sets (as xml) the "autowire" attribute
1537         */
1538        public void xsetAutowire(org.springframework.schema.beans.BeanDocument.Bean.Autowire autowire)
1539        {
1540            synchronized (monitor())
1541            {
1542                check_orphaned();
1543                org.springframework.schema.beans.BeanDocument.Bean.Autowire target = null;
1544                target = (org.springframework.schema.beans.BeanDocument.Bean.Autowire)get_store().find_attribute_user(AUTOWIRE$26);
1545                if (target == null)
1546                {
1547                    target = (org.springframework.schema.beans.BeanDocument.Bean.Autowire)get_store().add_attribute_user(AUTOWIRE$26);
1548                }
1549                target.set(autowire);
1550            }
1551        }
1552        
1553        /**
1554         * Unsets the "autowire" attribute
1555         */
1556        public void unsetAutowire()
1557        {
1558            synchronized (monitor())
1559            {
1560                check_orphaned();
1561                get_store().remove_attribute(AUTOWIRE$26);
1562            }
1563        }
1564        
1565        /**
1566         * Gets the "depends-on" attribute
1567         */
1568        public java.lang.String getDependsOn()
1569        {
1570            synchronized (monitor())
1571            {
1572                check_orphaned();
1573                org.apache.xmlbeans.SimpleValue target = null;
1574                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEPENDSON$28);
1575                if (target == null)
1576                {
1577                    return null;
1578                }
1579                return target.getStringValue();
1580            }
1581        }
1582        
1583        /**
1584         * Gets (as xml) the "depends-on" attribute
1585         */
1586        public org.apache.xmlbeans.XmlString xgetDependsOn()
1587        {
1588            synchronized (monitor())
1589            {
1590                check_orphaned();
1591                org.apache.xmlbeans.XmlString target = null;
1592                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEPENDSON$28);
1593                return target;
1594            }
1595        }
1596        
1597        /**
1598         * True if has "depends-on" attribute
1599         */
1600        public boolean isSetDependsOn()
1601        {
1602            synchronized (monitor())
1603            {
1604                check_orphaned();
1605                return get_store().find_attribute_user(DEPENDSON$28) != null;
1606            }
1607        }
1608        
1609        /**
1610         * Sets the "depends-on" attribute
1611         */
1612        public void setDependsOn(java.lang.String dependsOn)
1613        {
1614            synchronized (monitor())
1615            {
1616                check_orphaned();
1617                org.apache.xmlbeans.SimpleValue target = null;
1618                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DEPENDSON$28);
1619                if (target == null)
1620                {
1621                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DEPENDSON$28);
1622                }
1623                target.setStringValue(dependsOn);
1624            }
1625        }
1626        
1627        /**
1628         * Sets (as xml) the "depends-on" attribute
1629         */
1630        public void xsetDependsOn(org.apache.xmlbeans.XmlString dependsOn)
1631        {
1632            synchronized (monitor())
1633            {
1634                check_orphaned();
1635                org.apache.xmlbeans.XmlString target = null;
1636                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DEPENDSON$28);
1637                if (target == null)
1638                {
1639                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(DEPENDSON$28);
1640                }
1641                target.set(dependsOn);
1642            }
1643        }
1644        
1645        /**
1646         * Unsets the "depends-on" attribute
1647         */
1648        public void unsetDependsOn()
1649        {
1650            synchronized (monitor())
1651            {
1652                check_orphaned();
1653                get_store().remove_attribute(DEPENDSON$28);
1654            }
1655        }
1656        
1657        /**
1658         * Gets the "autowire-candidate" attribute
1659         */
1660        public org.springframework.schema.beans.DefaultableBoolean.Enum getAutowireCandidate()
1661        {
1662            synchronized (monitor())
1663            {
1664                check_orphaned();
1665                org.apache.xmlbeans.SimpleValue target = null;
1666                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(AUTOWIRECANDIDATE$30);
1667                if (target == null)
1668                {
1669                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(AUTOWIRECANDIDATE$30);
1670                }
1671                if (target == null)
1672                {
1673                    return null;
1674                }
1675                return (org.springframework.schema.beans.DefaultableBoolean.Enum)target.getEnumValue();
1676            }
1677        }
1678        
1679        /**
1680         * Gets (as xml) the "autowire-candidate" attribute
1681         */
1682        public org.springframework.schema.beans.DefaultableBoolean xgetAutowireCandidate()
1683        {
1684            synchronized (monitor())
1685            {
1686                check_orphaned();
1687                org.springframework.schema.beans.DefaultableBoolean target = null;
1688                target = (org.springframework.schema.beans.DefaultableBoolean)get_store().find_attribute_user(AUTOWIRECANDIDATE$30);
1689                if (target == null)
1690                {
1691                    target = (org.springframework.schema.beans.DefaultableBoolean)get_default_attribute_value(AUTOWIRECANDIDATE$30);
1692                }
1693                return target;
1694            }
1695        }
1696        
1697        /**
1698         * True if has "autowire-candidate" attribute
1699         */
1700        public boolean isSetAutowireCandidate()
1701        {
1702            synchronized (monitor())
1703            {
1704                check_orphaned();
1705                return get_store().find_attribute_user(AUTOWIRECANDIDATE$30) != null;
1706            }
1707        }
1708        
1709        /**
1710         * Sets the "autowire-candidate" attribute
1711         */
1712        public void setAutowireCandidate(org.springframework.schema.beans.DefaultableBoolean.Enum autowireCandidate)
1713        {
1714            synchronized (monitor())
1715            {
1716                check_orphaned();
1717                org.apache.xmlbeans.SimpleValue target = null;
1718                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(AUTOWIRECANDIDATE$30);
1719                if (target == null)
1720                {
1721                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(AUTOWIRECANDIDATE$30);
1722                }
1723                target.setEnumValue(autowireCandidate);
1724            }
1725        }
1726        
1727        /**
1728         * Sets (as xml) the "autowire-candidate" attribute
1729         */
1730        public void xsetAutowireCandidate(org.springframework.schema.beans.DefaultableBoolean autowireCandidate)
1731        {
1732            synchronized (monitor())
1733            {
1734                check_orphaned();
1735                org.springframework.schema.beans.DefaultableBoolean target = null;
1736                target = (org.springframework.schema.beans.DefaultableBoolean)get_store().find_attribute_user(AUTOWIRECANDIDATE$30);
1737                if (target == null)
1738                {
1739                    target = (org.springframework.schema.beans.DefaultableBoolean)get_store().add_attribute_user(AUTOWIRECANDIDATE$30);
1740                }
1741                target.set(autowireCandidate);
1742            }
1743        }
1744        
1745        /**
1746         * Unsets the "autowire-candidate" attribute
1747         */
1748        public void unsetAutowireCandidate()
1749        {
1750            synchronized (monitor())
1751            {
1752                check_orphaned();
1753                get_store().remove_attribute(AUTOWIRECANDIDATE$30);
1754            }
1755        }
1756        
1757        /**
1758         * Gets the "primary" attribute
1759         */
1760        public boolean getPrimary()
1761        {
1762            synchronized (monitor())
1763            {
1764                check_orphaned();
1765                org.apache.xmlbeans.SimpleValue target = null;
1766                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PRIMARY$32);
1767                if (target == null)
1768                {
1769                    return false;
1770                }
1771                return target.getBooleanValue();
1772            }
1773        }
1774        
1775        /**
1776         * Gets (as xml) the "primary" attribute
1777         */
1778        public org.apache.xmlbeans.XmlBoolean xgetPrimary()
1779        {
1780            synchronized (monitor())
1781            {
1782                check_orphaned();
1783                org.apache.xmlbeans.XmlBoolean target = null;
1784                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(PRIMARY$32);
1785                return target;
1786            }
1787        }
1788        
1789        /**
1790         * True if has "primary" attribute
1791         */
1792        public boolean isSetPrimary()
1793        {
1794            synchronized (monitor())
1795            {
1796                check_orphaned();
1797                return get_store().find_attribute_user(PRIMARY$32) != null;
1798            }
1799        }
1800        
1801        /**
1802         * Sets the "primary" attribute
1803         */
1804        public void setPrimary(boolean primary)
1805        {
1806            synchronized (monitor())
1807            {
1808                check_orphaned();
1809                org.apache.xmlbeans.SimpleValue target = null;
1810                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PRIMARY$32);
1811                if (target == null)
1812                {
1813                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(PRIMARY$32);
1814                }
1815                target.setBooleanValue(primary);
1816            }
1817        }
1818        
1819        /**
1820         * Sets (as xml) the "primary" attribute
1821         */
1822        public void xsetPrimary(org.apache.xmlbeans.XmlBoolean primary)
1823        {
1824            synchronized (monitor())
1825            {
1826                check_orphaned();
1827                org.apache.xmlbeans.XmlBoolean target = null;
1828                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(PRIMARY$32);
1829                if (target == null)
1830                {
1831                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(PRIMARY$32);
1832                }
1833                target.set(primary);
1834            }
1835        }
1836        
1837        /**
1838         * Unsets the "primary" attribute
1839         */
1840        public void unsetPrimary()
1841        {
1842            synchronized (monitor())
1843            {
1844                check_orphaned();
1845                get_store().remove_attribute(PRIMARY$32);
1846            }
1847        }
1848        
1849        /**
1850         * Gets the "init-method" attribute
1851         */
1852        public java.lang.String getInitMethod()
1853        {
1854            synchronized (monitor())
1855            {
1856                check_orphaned();
1857                org.apache.xmlbeans.SimpleValue target = null;
1858                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(INITMETHOD$34);
1859                if (target == null)
1860                {
1861                    return null;
1862                }
1863                return target.getStringValue();
1864            }
1865        }
1866        
1867        /**
1868         * Gets (as xml) the "init-method" attribute
1869         */
1870        public org.apache.xmlbeans.XmlString xgetInitMethod()
1871        {
1872            synchronized (monitor())
1873            {
1874                check_orphaned();
1875                org.apache.xmlbeans.XmlString target = null;
1876                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(INITMETHOD$34);
1877                return target;
1878            }
1879        }
1880        
1881        /**
1882         * True if has "init-method" attribute
1883         */
1884        public boolean isSetInitMethod()
1885        {
1886            synchronized (monitor())
1887            {
1888                check_orphaned();
1889                return get_store().find_attribute_user(INITMETHOD$34) != null;
1890            }
1891        }
1892        
1893        /**
1894         * Sets the "init-method" attribute
1895         */
1896        public void setInitMethod(java.lang.String initMethod)
1897        {
1898            synchronized (monitor())
1899            {
1900                check_orphaned();
1901                org.apache.xmlbeans.SimpleValue target = null;
1902                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(INITMETHOD$34);
1903                if (target == null)
1904                {
1905                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(INITMETHOD$34);
1906                }
1907                target.setStringValue(initMethod);
1908            }
1909        }
1910        
1911        /**
1912         * Sets (as xml) the "init-method" attribute
1913         */
1914        public void xsetInitMethod(org.apache.xmlbeans.XmlString initMethod)
1915        {
1916            synchronized (monitor())
1917            {
1918                check_orphaned();
1919                org.apache.xmlbeans.XmlString target = null;
1920                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(INITMETHOD$34);
1921                if (target == null)
1922                {
1923                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(INITMETHOD$34);
1924                }
1925                target.set(initMethod);
1926            }
1927        }
1928        
1929        /**
1930         * Unsets the "init-method" attribute
1931         */
1932        public void unsetInitMethod()
1933        {
1934            synchronized (monitor())
1935            {
1936                check_orphaned();
1937                get_store().remove_attribute(INITMETHOD$34);
1938            }
1939        }
1940        
1941        /**
1942         * Gets the "destroy-method" attribute
1943         */
1944        public java.lang.String getDestroyMethod()
1945        {
1946            synchronized (monitor())
1947            {
1948                check_orphaned();
1949                org.apache.xmlbeans.SimpleValue target = null;
1950                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DESTROYMETHOD$36);
1951                if (target == null)
1952                {
1953                    return null;
1954                }
1955                return target.getStringValue();
1956            }
1957        }
1958        
1959        /**
1960         * Gets (as xml) the "destroy-method" attribute
1961         */
1962        public org.apache.xmlbeans.XmlString xgetDestroyMethod()
1963        {
1964            synchronized (monitor())
1965            {
1966                check_orphaned();
1967                org.apache.xmlbeans.XmlString target = null;
1968                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DESTROYMETHOD$36);
1969                return target;
1970            }
1971        }
1972        
1973        /**
1974         * True if has "destroy-method" attribute
1975         */
1976        public boolean isSetDestroyMethod()
1977        {
1978            synchronized (monitor())
1979            {
1980                check_orphaned();
1981                return get_store().find_attribute_user(DESTROYMETHOD$36) != null;
1982            }
1983        }
1984        
1985        /**
1986         * Sets the "destroy-method" attribute
1987         */
1988        public void setDestroyMethod(java.lang.String destroyMethod)
1989        {
1990            synchronized (monitor())
1991            {
1992                check_orphaned();
1993                org.apache.xmlbeans.SimpleValue target = null;
1994                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(DESTROYMETHOD$36);
1995                if (target == null)
1996                {
1997                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(DESTROYMETHOD$36);
1998                }
1999                target.setStringValue(destroyMethod);
2000            }
2001        }
2002        
2003        /**
2004         * Sets (as xml) the "destroy-method" attribute
2005         */
2006        public void xsetDestroyMethod(org.apache.xmlbeans.XmlString destroyMethod)
2007        {
2008            synchronized (monitor())
2009            {
2010                check_orphaned();
2011                org.apache.xmlbeans.XmlString target = null;
2012                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(DESTROYMETHOD$36);
2013                if (target == null)
2014                {
2015                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(DESTROYMETHOD$36);
2016                }
2017                target.set(destroyMethod);
2018            }
2019        }
2020        
2021        /**
2022         * Unsets the "destroy-method" attribute
2023         */
2024        public void unsetDestroyMethod()
2025        {
2026            synchronized (monitor())
2027            {
2028                check_orphaned();
2029                get_store().remove_attribute(DESTROYMETHOD$36);
2030            }
2031        }
2032        
2033        /**
2034         * Gets the "factory-method" attribute
2035         */
2036        public java.lang.String getFactoryMethod()
2037        {
2038            synchronized (monitor())
2039            {
2040                check_orphaned();
2041                org.apache.xmlbeans.SimpleValue target = null;
2042                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FACTORYMETHOD$38);
2043                if (target == null)
2044                {
2045                    return null;
2046                }
2047                return target.getStringValue();
2048            }
2049        }
2050        
2051        /**
2052         * Gets (as xml) the "factory-method" attribute
2053         */
2054        public org.apache.xmlbeans.XmlString xgetFactoryMethod()
2055        {
2056            synchronized (monitor())
2057            {
2058                check_orphaned();
2059                org.apache.xmlbeans.XmlString target = null;
2060                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(FACTORYMETHOD$38);
2061                return target;
2062            }
2063        }
2064        
2065        /**
2066         * True if has "factory-method" attribute
2067         */
2068        public boolean isSetFactoryMethod()
2069        {
2070            synchronized (monitor())
2071            {
2072                check_orphaned();
2073                return get_store().find_attribute_user(FACTORYMETHOD$38) != null;
2074            }
2075        }
2076        
2077        /**
2078         * Sets the "factory-method" attribute
2079         */
2080        public void setFactoryMethod(java.lang.String factoryMethod)
2081        {
2082            synchronized (monitor())
2083            {
2084                check_orphaned();
2085                org.apache.xmlbeans.SimpleValue target = null;
2086                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FACTORYMETHOD$38);
2087                if (target == null)
2088                {
2089                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(FACTORYMETHOD$38);
2090                }
2091                target.setStringValue(factoryMethod);
2092            }
2093        }
2094        
2095        /**
2096         * Sets (as xml) the "factory-method" attribute
2097         */
2098        public void xsetFactoryMethod(org.apache.xmlbeans.XmlString factoryMethod)
2099        {
2100            synchronized (monitor())
2101            {
2102                check_orphaned();
2103                org.apache.xmlbeans.XmlString target = null;
2104                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(FACTORYMETHOD$38);
2105                if (target == null)
2106                {
2107                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(FACTORYMETHOD$38);
2108                }
2109                target.set(factoryMethod);
2110            }
2111        }
2112        
2113        /**
2114         * Unsets the "factory-method" attribute
2115         */
2116        public void unsetFactoryMethod()
2117        {
2118            synchronized (monitor())
2119            {
2120                check_orphaned();
2121                get_store().remove_attribute(FACTORYMETHOD$38);
2122            }
2123        }
2124        
2125        /**
2126         * Gets the "factory-bean" attribute
2127         */
2128        public java.lang.String getFactoryBean()
2129        {
2130            synchronized (monitor())
2131            {
2132                check_orphaned();
2133                org.apache.xmlbeans.SimpleValue target = null;
2134                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FACTORYBEAN$40);
2135                if (target == null)
2136                {
2137                    return null;
2138                }
2139                return target.getStringValue();
2140            }
2141        }
2142        
2143        /**
2144         * Gets (as xml) the "factory-bean" attribute
2145         */
2146        public org.apache.xmlbeans.XmlString xgetFactoryBean()
2147        {
2148            synchronized (monitor())
2149            {
2150                check_orphaned();
2151                org.apache.xmlbeans.XmlString target = null;
2152                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(FACTORYBEAN$40);
2153                return target;
2154            }
2155        }
2156        
2157        /**
2158         * True if has "factory-bean" attribute
2159         */
2160        public boolean isSetFactoryBean()
2161        {
2162            synchronized (monitor())
2163            {
2164                check_orphaned();
2165                return get_store().find_attribute_user(FACTORYBEAN$40) != null;
2166            }
2167        }
2168        
2169        /**
2170         * Sets the "factory-bean" attribute
2171         */
2172        public void setFactoryBean(java.lang.String factoryBean)
2173        {
2174            synchronized (monitor())
2175            {
2176                check_orphaned();
2177                org.apache.xmlbeans.SimpleValue target = null;
2178                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FACTORYBEAN$40);
2179                if (target == null)
2180                {
2181                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(FACTORYBEAN$40);
2182                }
2183                target.setStringValue(factoryBean);
2184            }
2185        }
2186        
2187        /**
2188         * Sets (as xml) the "factory-bean" attribute
2189         */
2190        public void xsetFactoryBean(org.apache.xmlbeans.XmlString factoryBean)
2191        {
2192            synchronized (monitor())
2193            {
2194                check_orphaned();
2195                org.apache.xmlbeans.XmlString target = null;
2196                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(FACTORYBEAN$40);
2197                if (target == null)
2198                {
2199                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(FACTORYBEAN$40);
2200                }
2201                target.set(factoryBean);
2202            }
2203        }
2204        
2205        /**
2206         * Unsets the "factory-bean" attribute
2207         */
2208        public void unsetFactoryBean()
2209        {
2210            synchronized (monitor())
2211            {
2212                check_orphaned();
2213                get_store().remove_attribute(FACTORYBEAN$40);
2214            }
2215        }
2216        /**
2217         * An XML autowire(@).
2218         *
2219         * This is an atomic type that is a restriction of org.springframework.schema.beans.BeanDocument$Bean$Autowire.
2220         */
2221        public static class AutowireImpl extends org.apache.xmlbeans.impl.values.JavaStringEnumerationHolderEx implements org.springframework.schema.beans.BeanDocument.Bean.Autowire
2222        {
2223            private static final long serialVersionUID = 1L;
2224            
2225            public AutowireImpl(org.apache.xmlbeans.SchemaType sType)
2226            {
2227                super(sType, false);
2228            }
2229            
2230            protected AutowireImpl(org.apache.xmlbeans.SchemaType sType, boolean b)
2231            {
2232                super(sType, b);
2233            }
2234        }
2235    }
2236}