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