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