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