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}