001/* 002 * XML Type: entryType 003 * Namespace: http://www.springframework.org/schema/beans 004 * Java type: org.springframework.schema.beans.EntryType 005 * 006 * Automatically generated - do not modify. 007 */ 008package org.springframework.schema.beans.impl; 009/** 010 * An XML entryType(@http://www.springframework.org/schema/beans). 011 * 012 * This is a complex type. 013 */ 014public class EntryTypeImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.springframework.schema.beans.EntryType 015{ 016 private static final long serialVersionUID = 1L; 017 018 public EntryTypeImpl(org.apache.xmlbeans.SchemaType sType) 019 { 020 super(sType); 021 } 022 023 private static final javax.xml.namespace.QName KEY$0 = 024 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "key"); 025 private static final javax.xml.namespace.QName DESCRIPTION$2 = 026 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "description"); 027 private static final javax.xml.namespace.QName BEAN$4 = 028 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "bean"); 029 private static final javax.xml.namespace.QName REF$6 = 030 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "ref"); 031 private static final javax.xml.namespace.QName IDREF$8 = 032 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "idref"); 033 private static final javax.xml.namespace.QName VALUE$10 = 034 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "value"); 035 private static final javax.xml.namespace.QName NULL$12 = 036 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "null"); 037 private static final javax.xml.namespace.QName ARRAY$14 = 038 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "array"); 039 private static final javax.xml.namespace.QName LIST$16 = 040 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "list"); 041 private static final javax.xml.namespace.QName SET$18 = 042 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "set"); 043 private static final javax.xml.namespace.QName MAP$20 = 044 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "map"); 045 private static final javax.xml.namespace.QName PROPS$22 = 046 new javax.xml.namespace.QName("http://www.springframework.org/schema/beans", "props"); 047 private static final javax.xml.namespace.QName KEY2$24 = 048 new javax.xml.namespace.QName("", "key"); 049 private static final javax.xml.namespace.QName KEYREF$26 = 050 new javax.xml.namespace.QName("", "key-ref"); 051 private static final javax.xml.namespace.QName VALUE2$28 = 052 new javax.xml.namespace.QName("", "value"); 053 private static final javax.xml.namespace.QName VALUEREF$30 = 054 new javax.xml.namespace.QName("", "value-ref"); 055 056 057 /** 058 * Gets the "key" element 059 */ 060 public org.springframework.schema.beans.KeyDocument.Key getKey() 061 { 062 synchronized (monitor()) 063 { 064 check_orphaned(); 065 org.springframework.schema.beans.KeyDocument.Key target = null; 066 target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0); 067 if (target == null) 068 { 069 return null; 070 } 071 return target; 072 } 073 } 074 075 /** 076 * True if has "key" element 077 */ 078 public boolean isSetKey() 079 { 080 synchronized (monitor()) 081 { 082 check_orphaned(); 083 return get_store().count_elements(KEY$0) != 0; 084 } 085 } 086 087 /** 088 * Sets the "key" element 089 */ 090 public void setKey(org.springframework.schema.beans.KeyDocument.Key key) 091 { 092 synchronized (monitor()) 093 { 094 check_orphaned(); 095 org.springframework.schema.beans.KeyDocument.Key target = null; 096 target = (org.springframework.schema.beans.KeyDocument.Key)get_store().find_element_user(KEY$0, 0); 097 if (target == null) 098 { 099 target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0); 100 } 101 target.set(key); 102 } 103 } 104 105 /** 106 * Appends and returns a new empty "key" element 107 */ 108 public org.springframework.schema.beans.KeyDocument.Key addNewKey() 109 { 110 synchronized (monitor()) 111 { 112 check_orphaned(); 113 org.springframework.schema.beans.KeyDocument.Key target = null; 114 target = (org.springframework.schema.beans.KeyDocument.Key)get_store().add_element_user(KEY$0); 115 return target; 116 } 117 } 118 119 /** 120 * Unsets the "key" element 121 */ 122 public void unsetKey() 123 { 124 synchronized (monitor()) 125 { 126 check_orphaned(); 127 get_store().remove_element(KEY$0, 0); 128 } 129 } 130 131 /** 132 * Gets the "description" element 133 */ 134 public org.springframework.schema.beans.DescriptionDocument.Description getDescription() 135 { 136 synchronized (monitor()) 137 { 138 check_orphaned(); 139 org.springframework.schema.beans.DescriptionDocument.Description target = null; 140 target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$2, 0); 141 if (target == null) 142 { 143 return null; 144 } 145 return target; 146 } 147 } 148 149 /** 150 * True if has "description" element 151 */ 152 public boolean isSetDescription() 153 { 154 synchronized (monitor()) 155 { 156 check_orphaned(); 157 return get_store().count_elements(DESCRIPTION$2) != 0; 158 } 159 } 160 161 /** 162 * Sets the "description" element 163 */ 164 public void setDescription(org.springframework.schema.beans.DescriptionDocument.Description description) 165 { 166 synchronized (monitor()) 167 { 168 check_orphaned(); 169 org.springframework.schema.beans.DescriptionDocument.Description target = null; 170 target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().find_element_user(DESCRIPTION$2, 0); 171 if (target == null) 172 { 173 target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$2); 174 } 175 target.set(description); 176 } 177 } 178 179 /** 180 * Appends and returns a new empty "description" element 181 */ 182 public org.springframework.schema.beans.DescriptionDocument.Description addNewDescription() 183 { 184 synchronized (monitor()) 185 { 186 check_orphaned(); 187 org.springframework.schema.beans.DescriptionDocument.Description target = null; 188 target = (org.springframework.schema.beans.DescriptionDocument.Description)get_store().add_element_user(DESCRIPTION$2); 189 return target; 190 } 191 } 192 193 /** 194 * Unsets the "description" element 195 */ 196 public void unsetDescription() 197 { 198 synchronized (monitor()) 199 { 200 check_orphaned(); 201 get_store().remove_element(DESCRIPTION$2, 0); 202 } 203 } 204 205 /** 206 * Gets array of all "bean" elements 207 */ 208 public org.springframework.schema.beans.BeanDocument.Bean[] getBeanArray() 209 { 210 synchronized (monitor()) 211 { 212 check_orphaned(); 213 java.util.List targetList = new java.util.ArrayList(); 214 get_store().find_all_element_users(BEAN$4, targetList); 215 org.springframework.schema.beans.BeanDocument.Bean[] result = new org.springframework.schema.beans.BeanDocument.Bean[targetList.size()]; 216 targetList.toArray(result); 217 return result; 218 } 219 } 220 221 /** 222 * Gets ith "bean" element 223 */ 224 public org.springframework.schema.beans.BeanDocument.Bean getBeanArray(int i) 225 { 226 synchronized (monitor()) 227 { 228 check_orphaned(); 229 org.springframework.schema.beans.BeanDocument.Bean target = null; 230 target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$4, i); 231 if (target == null) 232 { 233 throw new IndexOutOfBoundsException(); 234 } 235 return target; 236 } 237 } 238 239 /** 240 * Returns number of "bean" element 241 */ 242 public int sizeOfBeanArray() 243 { 244 synchronized (monitor()) 245 { 246 check_orphaned(); 247 return get_store().count_elements(BEAN$4); 248 } 249 } 250 251 /** 252 * Sets array of all "bean" element 253 */ 254 public void setBeanArray(org.springframework.schema.beans.BeanDocument.Bean[] beanArray) 255 { 256 synchronized (monitor()) 257 { 258 check_orphaned(); 259 arraySetterHelper(beanArray, BEAN$4); 260 } 261 } 262 263 /** 264 * Sets ith "bean" element 265 */ 266 public void setBeanArray(int i, org.springframework.schema.beans.BeanDocument.Bean bean) 267 { 268 synchronized (monitor()) 269 { 270 check_orphaned(); 271 org.springframework.schema.beans.BeanDocument.Bean target = null; 272 target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().find_element_user(BEAN$4, i); 273 if (target == null) 274 { 275 throw new IndexOutOfBoundsException(); 276 } 277 target.set(bean); 278 } 279 } 280 281 /** 282 * Inserts and returns a new empty value (as xml) as the ith "bean" element 283 */ 284 public org.springframework.schema.beans.BeanDocument.Bean insertNewBean(int i) 285 { 286 synchronized (monitor()) 287 { 288 check_orphaned(); 289 org.springframework.schema.beans.BeanDocument.Bean target = null; 290 target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().insert_element_user(BEAN$4, i); 291 return target; 292 } 293 } 294 295 /** 296 * Appends and returns a new empty value (as xml) as the last "bean" element 297 */ 298 public org.springframework.schema.beans.BeanDocument.Bean addNewBean() 299 { 300 synchronized (monitor()) 301 { 302 check_orphaned(); 303 org.springframework.schema.beans.BeanDocument.Bean target = null; 304 target = (org.springframework.schema.beans.BeanDocument.Bean)get_store().add_element_user(BEAN$4); 305 return target; 306 } 307 } 308 309 /** 310 * Removes the ith "bean" element 311 */ 312 public void removeBean(int i) 313 { 314 synchronized (monitor()) 315 { 316 check_orphaned(); 317 get_store().remove_element(BEAN$4, i); 318 } 319 } 320 321 /** 322 * Gets array of all "ref" elements 323 */ 324 public org.springframework.schema.beans.RefDocument.Ref[] getRefArray() 325 { 326 synchronized (monitor()) 327 { 328 check_orphaned(); 329 java.util.List targetList = new java.util.ArrayList(); 330 get_store().find_all_element_users(REF$6, targetList); 331 org.springframework.schema.beans.RefDocument.Ref[] result = new org.springframework.schema.beans.RefDocument.Ref[targetList.size()]; 332 targetList.toArray(result); 333 return result; 334 } 335 } 336 337 /** 338 * Gets ith "ref" element 339 */ 340 public org.springframework.schema.beans.RefDocument.Ref getRefArray(int i) 341 { 342 synchronized (monitor()) 343 { 344 check_orphaned(); 345 org.springframework.schema.beans.RefDocument.Ref target = null; 346 target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$6, i); 347 if (target == null) 348 { 349 throw new IndexOutOfBoundsException(); 350 } 351 return target; 352 } 353 } 354 355 /** 356 * Returns number of "ref" element 357 */ 358 public int sizeOfRefArray() 359 { 360 synchronized (monitor()) 361 { 362 check_orphaned(); 363 return get_store().count_elements(REF$6); 364 } 365 } 366 367 /** 368 * Sets array of all "ref" element 369 */ 370 public void setRefArray(org.springframework.schema.beans.RefDocument.Ref[] refArray) 371 { 372 synchronized (monitor()) 373 { 374 check_orphaned(); 375 arraySetterHelper(refArray, REF$6); 376 } 377 } 378 379 /** 380 * Sets ith "ref" element 381 */ 382 public void setRefArray(int i, org.springframework.schema.beans.RefDocument.Ref ref) 383 { 384 synchronized (monitor()) 385 { 386 check_orphaned(); 387 org.springframework.schema.beans.RefDocument.Ref target = null; 388 target = (org.springframework.schema.beans.RefDocument.Ref)get_store().find_element_user(REF$6, i); 389 if (target == null) 390 { 391 throw new IndexOutOfBoundsException(); 392 } 393 target.set(ref); 394 } 395 } 396 397 /** 398 * Inserts and returns a new empty value (as xml) as the ith "ref" element 399 */ 400 public org.springframework.schema.beans.RefDocument.Ref insertNewRef(int i) 401 { 402 synchronized (monitor()) 403 { 404 check_orphaned(); 405 org.springframework.schema.beans.RefDocument.Ref target = null; 406 target = (org.springframework.schema.beans.RefDocument.Ref)get_store().insert_element_user(REF$6, i); 407 return target; 408 } 409 } 410 411 /** 412 * Appends and returns a new empty value (as xml) as the last "ref" element 413 */ 414 public org.springframework.schema.beans.RefDocument.Ref addNewRef() 415 { 416 synchronized (monitor()) 417 { 418 check_orphaned(); 419 org.springframework.schema.beans.RefDocument.Ref target = null; 420 target = (org.springframework.schema.beans.RefDocument.Ref)get_store().add_element_user(REF$6); 421 return target; 422 } 423 } 424 425 /** 426 * Removes the ith "ref" element 427 */ 428 public void removeRef(int i) 429 { 430 synchronized (monitor()) 431 { 432 check_orphaned(); 433 get_store().remove_element(REF$6, i); 434 } 435 } 436 437 /** 438 * Gets array of all "idref" elements 439 */ 440 public org.springframework.schema.beans.IdrefDocument.Idref[] getIdrefArray() 441 { 442 synchronized (monitor()) 443 { 444 check_orphaned(); 445 java.util.List targetList = new java.util.ArrayList(); 446 get_store().find_all_element_users(IDREF$8, targetList); 447 org.springframework.schema.beans.IdrefDocument.Idref[] result = new org.springframework.schema.beans.IdrefDocument.Idref[targetList.size()]; 448 targetList.toArray(result); 449 return result; 450 } 451 } 452 453 /** 454 * Gets ith "idref" element 455 */ 456 public org.springframework.schema.beans.IdrefDocument.Idref getIdrefArray(int i) 457 { 458 synchronized (monitor()) 459 { 460 check_orphaned(); 461 org.springframework.schema.beans.IdrefDocument.Idref target = null; 462 target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$8, i); 463 if (target == null) 464 { 465 throw new IndexOutOfBoundsException(); 466 } 467 return target; 468 } 469 } 470 471 /** 472 * Returns number of "idref" element 473 */ 474 public int sizeOfIdrefArray() 475 { 476 synchronized (monitor()) 477 { 478 check_orphaned(); 479 return get_store().count_elements(IDREF$8); 480 } 481 } 482 483 /** 484 * Sets array of all "idref" element 485 */ 486 public void setIdrefArray(org.springframework.schema.beans.IdrefDocument.Idref[] idrefArray) 487 { 488 synchronized (monitor()) 489 { 490 check_orphaned(); 491 arraySetterHelper(idrefArray, IDREF$8); 492 } 493 } 494 495 /** 496 * Sets ith "idref" element 497 */ 498 public void setIdrefArray(int i, org.springframework.schema.beans.IdrefDocument.Idref idref) 499 { 500 synchronized (monitor()) 501 { 502 check_orphaned(); 503 org.springframework.schema.beans.IdrefDocument.Idref target = null; 504 target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().find_element_user(IDREF$8, i); 505 if (target == null) 506 { 507 throw new IndexOutOfBoundsException(); 508 } 509 target.set(idref); 510 } 511 } 512 513 /** 514 * Inserts and returns a new empty value (as xml) as the ith "idref" element 515 */ 516 public org.springframework.schema.beans.IdrefDocument.Idref insertNewIdref(int i) 517 { 518 synchronized (monitor()) 519 { 520 check_orphaned(); 521 org.springframework.schema.beans.IdrefDocument.Idref target = null; 522 target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().insert_element_user(IDREF$8, i); 523 return target; 524 } 525 } 526 527 /** 528 * Appends and returns a new empty value (as xml) as the last "idref" element 529 */ 530 public org.springframework.schema.beans.IdrefDocument.Idref addNewIdref() 531 { 532 synchronized (monitor()) 533 { 534 check_orphaned(); 535 org.springframework.schema.beans.IdrefDocument.Idref target = null; 536 target = (org.springframework.schema.beans.IdrefDocument.Idref)get_store().add_element_user(IDREF$8); 537 return target; 538 } 539 } 540 541 /** 542 * Removes the ith "idref" element 543 */ 544 public void removeIdref(int i) 545 { 546 synchronized (monitor()) 547 { 548 check_orphaned(); 549 get_store().remove_element(IDREF$8, i); 550 } 551 } 552 553 /** 554 * Gets array of all "value" elements 555 */ 556 public org.springframework.schema.beans.ValueDocument.Value[] getValueArray() 557 { 558 synchronized (monitor()) 559 { 560 check_orphaned(); 561 java.util.List targetList = new java.util.ArrayList(); 562 get_store().find_all_element_users(VALUE$10, targetList); 563 org.springframework.schema.beans.ValueDocument.Value[] result = new org.springframework.schema.beans.ValueDocument.Value[targetList.size()]; 564 targetList.toArray(result); 565 return result; 566 } 567 } 568 569 /** 570 * Gets ith "value" element 571 */ 572 public org.springframework.schema.beans.ValueDocument.Value getValueArray(int i) 573 { 574 synchronized (monitor()) 575 { 576 check_orphaned(); 577 org.springframework.schema.beans.ValueDocument.Value target = null; 578 target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$10, i); 579 if (target == null) 580 { 581 throw new IndexOutOfBoundsException(); 582 } 583 return target; 584 } 585 } 586 587 /** 588 * Returns number of "value" element 589 */ 590 public int sizeOfValueArray() 591 { 592 synchronized (monitor()) 593 { 594 check_orphaned(); 595 return get_store().count_elements(VALUE$10); 596 } 597 } 598 599 /** 600 * Sets array of all "value" element 601 */ 602 public void setValueArray(org.springframework.schema.beans.ValueDocument.Value[] valueArray) 603 { 604 synchronized (monitor()) 605 { 606 check_orphaned(); 607 arraySetterHelper(valueArray, VALUE$10); 608 } 609 } 610 611 /** 612 * Sets ith "value" element 613 */ 614 public void setValueArray(int i, org.springframework.schema.beans.ValueDocument.Value value) 615 { 616 synchronized (monitor()) 617 { 618 check_orphaned(); 619 org.springframework.schema.beans.ValueDocument.Value target = null; 620 target = (org.springframework.schema.beans.ValueDocument.Value)get_store().find_element_user(VALUE$10, i); 621 if (target == null) 622 { 623 throw new IndexOutOfBoundsException(); 624 } 625 target.set(value); 626 } 627 } 628 629 /** 630 * Inserts and returns a new empty value (as xml) as the ith "value" element 631 */ 632 public org.springframework.schema.beans.ValueDocument.Value insertNewValue(int i) 633 { 634 synchronized (monitor()) 635 { 636 check_orphaned(); 637 org.springframework.schema.beans.ValueDocument.Value target = null; 638 target = (org.springframework.schema.beans.ValueDocument.Value)get_store().insert_element_user(VALUE$10, i); 639 return target; 640 } 641 } 642 643 /** 644 * Appends and returns a new empty value (as xml) as the last "value" element 645 */ 646 public org.springframework.schema.beans.ValueDocument.Value addNewValue() 647 { 648 synchronized (monitor()) 649 { 650 check_orphaned(); 651 org.springframework.schema.beans.ValueDocument.Value target = null; 652 target = (org.springframework.schema.beans.ValueDocument.Value)get_store().add_element_user(VALUE$10); 653 return target; 654 } 655 } 656 657 /** 658 * Removes the ith "value" element 659 */ 660 public void removeValue(int i) 661 { 662 synchronized (monitor()) 663 { 664 check_orphaned(); 665 get_store().remove_element(VALUE$10, i); 666 } 667 } 668 669 /** 670 * Gets array of all "null" elements 671 */ 672 public org.springframework.schema.beans.NullDocument.Null[] getNullArray() 673 { 674 synchronized (monitor()) 675 { 676 check_orphaned(); 677 java.util.List targetList = new java.util.ArrayList(); 678 get_store().find_all_element_users(NULL$12, targetList); 679 org.springframework.schema.beans.NullDocument.Null[] result = new org.springframework.schema.beans.NullDocument.Null[targetList.size()]; 680 targetList.toArray(result); 681 return result; 682 } 683 } 684 685 /** 686 * Gets ith "null" element 687 */ 688 public org.springframework.schema.beans.NullDocument.Null getNullArray(int i) 689 { 690 synchronized (monitor()) 691 { 692 check_orphaned(); 693 org.springframework.schema.beans.NullDocument.Null target = null; 694 target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$12, i); 695 if (target == null) 696 { 697 throw new IndexOutOfBoundsException(); 698 } 699 return target; 700 } 701 } 702 703 /** 704 * Returns number of "null" element 705 */ 706 public int sizeOfNullArray() 707 { 708 synchronized (monitor()) 709 { 710 check_orphaned(); 711 return get_store().count_elements(NULL$12); 712 } 713 } 714 715 /** 716 * Sets array of all "null" element 717 */ 718 public void setNullArray(org.springframework.schema.beans.NullDocument.Null[] xnullArray) 719 { 720 synchronized (monitor()) 721 { 722 check_orphaned(); 723 arraySetterHelper(xnullArray, NULL$12); 724 } 725 } 726 727 /** 728 * Sets ith "null" element 729 */ 730 public void setNullArray(int i, org.springframework.schema.beans.NullDocument.Null xnull) 731 { 732 synchronized (monitor()) 733 { 734 check_orphaned(); 735 org.springframework.schema.beans.NullDocument.Null target = null; 736 target = (org.springframework.schema.beans.NullDocument.Null)get_store().find_element_user(NULL$12, i); 737 if (target == null) 738 { 739 throw new IndexOutOfBoundsException(); 740 } 741 target.set(xnull); 742 } 743 } 744 745 /** 746 * Inserts and returns a new empty value (as xml) as the ith "null" element 747 */ 748 public org.springframework.schema.beans.NullDocument.Null insertNewNull(int i) 749 { 750 synchronized (monitor()) 751 { 752 check_orphaned(); 753 org.springframework.schema.beans.NullDocument.Null target = null; 754 target = (org.springframework.schema.beans.NullDocument.Null)get_store().insert_element_user(NULL$12, i); 755 return target; 756 } 757 } 758 759 /** 760 * Appends and returns a new empty value (as xml) as the last "null" element 761 */ 762 public org.springframework.schema.beans.NullDocument.Null addNewNull() 763 { 764 synchronized (monitor()) 765 { 766 check_orphaned(); 767 org.springframework.schema.beans.NullDocument.Null target = null; 768 target = (org.springframework.schema.beans.NullDocument.Null)get_store().add_element_user(NULL$12); 769 return target; 770 } 771 } 772 773 /** 774 * Removes the ith "null" element 775 */ 776 public void removeNull(int i) 777 { 778 synchronized (monitor()) 779 { 780 check_orphaned(); 781 get_store().remove_element(NULL$12, i); 782 } 783 } 784 785 /** 786 * Gets array of all "array" elements 787 */ 788 public org.springframework.schema.beans.ArrayDocument.Array[] getArrayArray() 789 { 790 synchronized (monitor()) 791 { 792 check_orphaned(); 793 java.util.List targetList = new java.util.ArrayList(); 794 get_store().find_all_element_users(ARRAY$14, targetList); 795 org.springframework.schema.beans.ArrayDocument.Array[] result = new org.springframework.schema.beans.ArrayDocument.Array[targetList.size()]; 796 targetList.toArray(result); 797 return result; 798 } 799 } 800 801 /** 802 * Gets ith "array" element 803 */ 804 public org.springframework.schema.beans.ArrayDocument.Array getArrayArray(int i) 805 { 806 synchronized (monitor()) 807 { 808 check_orphaned(); 809 org.springframework.schema.beans.ArrayDocument.Array target = null; 810 target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$14, i); 811 if (target == null) 812 { 813 throw new IndexOutOfBoundsException(); 814 } 815 return target; 816 } 817 } 818 819 /** 820 * Returns number of "array" element 821 */ 822 public int sizeOfArrayArray() 823 { 824 synchronized (monitor()) 825 { 826 check_orphaned(); 827 return get_store().count_elements(ARRAY$14); 828 } 829 } 830 831 /** 832 * Sets array of all "array" element 833 */ 834 public void setArrayArray(org.springframework.schema.beans.ArrayDocument.Array[] arrayArray) 835 { 836 synchronized (monitor()) 837 { 838 check_orphaned(); 839 arraySetterHelper(arrayArray, ARRAY$14); 840 } 841 } 842 843 /** 844 * Sets ith "array" element 845 */ 846 public void setArrayArray(int i, org.springframework.schema.beans.ArrayDocument.Array array) 847 { 848 synchronized (monitor()) 849 { 850 check_orphaned(); 851 org.springframework.schema.beans.ArrayDocument.Array target = null; 852 target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().find_element_user(ARRAY$14, i); 853 if (target == null) 854 { 855 throw new IndexOutOfBoundsException(); 856 } 857 target.set(array); 858 } 859 } 860 861 /** 862 * Inserts and returns a new empty value (as xml) as the ith "array" element 863 */ 864 public org.springframework.schema.beans.ArrayDocument.Array insertNewArray(int i) 865 { 866 synchronized (monitor()) 867 { 868 check_orphaned(); 869 org.springframework.schema.beans.ArrayDocument.Array target = null; 870 target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().insert_element_user(ARRAY$14, i); 871 return target; 872 } 873 } 874 875 /** 876 * Appends and returns a new empty value (as xml) as the last "array" element 877 */ 878 public org.springframework.schema.beans.ArrayDocument.Array addNewArray() 879 { 880 synchronized (monitor()) 881 { 882 check_orphaned(); 883 org.springframework.schema.beans.ArrayDocument.Array target = null; 884 target = (org.springframework.schema.beans.ArrayDocument.Array)get_store().add_element_user(ARRAY$14); 885 return target; 886 } 887 } 888 889 /** 890 * Removes the ith "array" element 891 */ 892 public void removeArray(int i) 893 { 894 synchronized (monitor()) 895 { 896 check_orphaned(); 897 get_store().remove_element(ARRAY$14, i); 898 } 899 } 900 901 /** 902 * Gets array of all "list" elements 903 */ 904 public org.springframework.schema.beans.ListDocument.List[] getListArray() 905 { 906 synchronized (monitor()) 907 { 908 check_orphaned(); 909 java.util.List targetList = new java.util.ArrayList(); 910 get_store().find_all_element_users(LIST$16, targetList); 911 org.springframework.schema.beans.ListDocument.List[] result = new org.springframework.schema.beans.ListDocument.List[targetList.size()]; 912 targetList.toArray(result); 913 return result; 914 } 915 } 916 917 /** 918 * Gets ith "list" element 919 */ 920 public org.springframework.schema.beans.ListDocument.List getListArray(int i) 921 { 922 synchronized (monitor()) 923 { 924 check_orphaned(); 925 org.springframework.schema.beans.ListDocument.List target = null; 926 target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$16, i); 927 if (target == null) 928 { 929 throw new IndexOutOfBoundsException(); 930 } 931 return target; 932 } 933 } 934 935 /** 936 * Returns number of "list" element 937 */ 938 public int sizeOfListArray() 939 { 940 synchronized (monitor()) 941 { 942 check_orphaned(); 943 return get_store().count_elements(LIST$16); 944 } 945 } 946 947 /** 948 * Sets array of all "list" element 949 */ 950 public void setListArray(org.springframework.schema.beans.ListDocument.List[] listArray) 951 { 952 synchronized (monitor()) 953 { 954 check_orphaned(); 955 arraySetterHelper(listArray, LIST$16); 956 } 957 } 958 959 /** 960 * Sets ith "list" element 961 */ 962 public void setListArray(int i, org.springframework.schema.beans.ListDocument.List list) 963 { 964 synchronized (monitor()) 965 { 966 check_orphaned(); 967 org.springframework.schema.beans.ListDocument.List target = null; 968 target = (org.springframework.schema.beans.ListDocument.List)get_store().find_element_user(LIST$16, i); 969 if (target == null) 970 { 971 throw new IndexOutOfBoundsException(); 972 } 973 target.set(list); 974 } 975 } 976 977 /** 978 * Inserts and returns a new empty value (as xml) as the ith "list" element 979 */ 980 public org.springframework.schema.beans.ListDocument.List insertNewList(int i) 981 { 982 synchronized (monitor()) 983 { 984 check_orphaned(); 985 org.springframework.schema.beans.ListDocument.List target = null; 986 target = (org.springframework.schema.beans.ListDocument.List)get_store().insert_element_user(LIST$16, i); 987 return target; 988 } 989 } 990 991 /** 992 * Appends and returns a new empty value (as xml) as the last "list" element 993 */ 994 public org.springframework.schema.beans.ListDocument.List addNewList() 995 { 996 synchronized (monitor()) 997 { 998 check_orphaned(); 999 org.springframework.schema.beans.ListDocument.List target = null; 1000 target = (org.springframework.schema.beans.ListDocument.List)get_store().add_element_user(LIST$16); 1001 return target; 1002 } 1003 } 1004 1005 /** 1006 * Removes the ith "list" element 1007 */ 1008 public void removeList(int i) 1009 { 1010 synchronized (monitor()) 1011 { 1012 check_orphaned(); 1013 get_store().remove_element(LIST$16, i); 1014 } 1015 } 1016 1017 /** 1018 * Gets array of all "set" elements 1019 */ 1020 public org.springframework.schema.beans.SetDocument.Set[] getSetArray() 1021 { 1022 synchronized (monitor()) 1023 { 1024 check_orphaned(); 1025 java.util.List targetList = new java.util.ArrayList(); 1026 get_store().find_all_element_users(SET$18, targetList); 1027 org.springframework.schema.beans.SetDocument.Set[] result = new org.springframework.schema.beans.SetDocument.Set[targetList.size()]; 1028 targetList.toArray(result); 1029 return result; 1030 } 1031 } 1032 1033 /** 1034 * Gets ith "set" element 1035 */ 1036 public org.springframework.schema.beans.SetDocument.Set getSetArray(int i) 1037 { 1038 synchronized (monitor()) 1039 { 1040 check_orphaned(); 1041 org.springframework.schema.beans.SetDocument.Set target = null; 1042 target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$18, i); 1043 if (target == null) 1044 { 1045 throw new IndexOutOfBoundsException(); 1046 } 1047 return target; 1048 } 1049 } 1050 1051 /** 1052 * Returns number of "set" element 1053 */ 1054 public int sizeOfSetArray() 1055 { 1056 synchronized (monitor()) 1057 { 1058 check_orphaned(); 1059 return get_store().count_elements(SET$18); 1060 } 1061 } 1062 1063 /** 1064 * Sets array of all "set" element 1065 */ 1066 public void setSetArray(org.springframework.schema.beans.SetDocument.Set[] setArray) 1067 { 1068 synchronized (monitor()) 1069 { 1070 check_orphaned(); 1071 arraySetterHelper(setArray, SET$18); 1072 } 1073 } 1074 1075 /** 1076 * Sets ith "set" element 1077 */ 1078 public void setSetArray(int i, org.springframework.schema.beans.SetDocument.Set set) 1079 { 1080 synchronized (monitor()) 1081 { 1082 check_orphaned(); 1083 org.springframework.schema.beans.SetDocument.Set target = null; 1084 target = (org.springframework.schema.beans.SetDocument.Set)get_store().find_element_user(SET$18, i); 1085 if (target == null) 1086 { 1087 throw new IndexOutOfBoundsException(); 1088 } 1089 target.set(set); 1090 } 1091 } 1092 1093 /** 1094 * Inserts and returns a new empty value (as xml) as the ith "set" element 1095 */ 1096 public org.springframework.schema.beans.SetDocument.Set insertNewSet(int i) 1097 { 1098 synchronized (monitor()) 1099 { 1100 check_orphaned(); 1101 org.springframework.schema.beans.SetDocument.Set target = null; 1102 target = (org.springframework.schema.beans.SetDocument.Set)get_store().insert_element_user(SET$18, i); 1103 return target; 1104 } 1105 } 1106 1107 /** 1108 * Appends and returns a new empty value (as xml) as the last "set" element 1109 */ 1110 public org.springframework.schema.beans.SetDocument.Set addNewSet() 1111 { 1112 synchronized (monitor()) 1113 { 1114 check_orphaned(); 1115 org.springframework.schema.beans.SetDocument.Set target = null; 1116 target = (org.springframework.schema.beans.SetDocument.Set)get_store().add_element_user(SET$18); 1117 return target; 1118 } 1119 } 1120 1121 /** 1122 * Removes the ith "set" element 1123 */ 1124 public void removeSet(int i) 1125 { 1126 synchronized (monitor()) 1127 { 1128 check_orphaned(); 1129 get_store().remove_element(SET$18, i); 1130 } 1131 } 1132 1133 /** 1134 * Gets array of all "map" elements 1135 */ 1136 public org.springframework.schema.beans.MapDocument.Map[] getMapArray() 1137 { 1138 synchronized (monitor()) 1139 { 1140 check_orphaned(); 1141 java.util.List targetList = new java.util.ArrayList(); 1142 get_store().find_all_element_users(MAP$20, targetList); 1143 org.springframework.schema.beans.MapDocument.Map[] result = new org.springframework.schema.beans.MapDocument.Map[targetList.size()]; 1144 targetList.toArray(result); 1145 return result; 1146 } 1147 } 1148 1149 /** 1150 * Gets ith "map" element 1151 */ 1152 public org.springframework.schema.beans.MapDocument.Map getMapArray(int i) 1153 { 1154 synchronized (monitor()) 1155 { 1156 check_orphaned(); 1157 org.springframework.schema.beans.MapDocument.Map target = null; 1158 target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$20, i); 1159 if (target == null) 1160 { 1161 throw new IndexOutOfBoundsException(); 1162 } 1163 return target; 1164 } 1165 } 1166 1167 /** 1168 * Returns number of "map" element 1169 */ 1170 public int sizeOfMapArray() 1171 { 1172 synchronized (monitor()) 1173 { 1174 check_orphaned(); 1175 return get_store().count_elements(MAP$20); 1176 } 1177 } 1178 1179 /** 1180 * Sets array of all "map" element 1181 */ 1182 public void setMapArray(org.springframework.schema.beans.MapDocument.Map[] mapArray) 1183 { 1184 synchronized (monitor()) 1185 { 1186 check_orphaned(); 1187 arraySetterHelper(mapArray, MAP$20); 1188 } 1189 } 1190 1191 /** 1192 * Sets ith "map" element 1193 */ 1194 public void setMapArray(int i, org.springframework.schema.beans.MapDocument.Map map) 1195 { 1196 synchronized (monitor()) 1197 { 1198 check_orphaned(); 1199 org.springframework.schema.beans.MapDocument.Map target = null; 1200 target = (org.springframework.schema.beans.MapDocument.Map)get_store().find_element_user(MAP$20, i); 1201 if (target == null) 1202 { 1203 throw new IndexOutOfBoundsException(); 1204 } 1205 target.set(map); 1206 } 1207 } 1208 1209 /** 1210 * Inserts and returns a new empty value (as xml) as the ith "map" element 1211 */ 1212 public org.springframework.schema.beans.MapDocument.Map insertNewMap(int i) 1213 { 1214 synchronized (monitor()) 1215 { 1216 check_orphaned(); 1217 org.springframework.schema.beans.MapDocument.Map target = null; 1218 target = (org.springframework.schema.beans.MapDocument.Map)get_store().insert_element_user(MAP$20, i); 1219 return target; 1220 } 1221 } 1222 1223 /** 1224 * Appends and returns a new empty value (as xml) as the last "map" element 1225 */ 1226 public org.springframework.schema.beans.MapDocument.Map addNewMap() 1227 { 1228 synchronized (monitor()) 1229 { 1230 check_orphaned(); 1231 org.springframework.schema.beans.MapDocument.Map target = null; 1232 target = (org.springframework.schema.beans.MapDocument.Map)get_store().add_element_user(MAP$20); 1233 return target; 1234 } 1235 } 1236 1237 /** 1238 * Removes the ith "map" element 1239 */ 1240 public void removeMap(int i) 1241 { 1242 synchronized (monitor()) 1243 { 1244 check_orphaned(); 1245 get_store().remove_element(MAP$20, i); 1246 } 1247 } 1248 1249 /** 1250 * Gets array of all "props" elements 1251 */ 1252 public org.springframework.schema.beans.PropsDocument.Props[] getPropsArray() 1253 { 1254 synchronized (monitor()) 1255 { 1256 check_orphaned(); 1257 java.util.List targetList = new java.util.ArrayList(); 1258 get_store().find_all_element_users(PROPS$22, targetList); 1259 org.springframework.schema.beans.PropsDocument.Props[] result = new org.springframework.schema.beans.PropsDocument.Props[targetList.size()]; 1260 targetList.toArray(result); 1261 return result; 1262 } 1263 } 1264 1265 /** 1266 * Gets ith "props" element 1267 */ 1268 public org.springframework.schema.beans.PropsDocument.Props getPropsArray(int i) 1269 { 1270 synchronized (monitor()) 1271 { 1272 check_orphaned(); 1273 org.springframework.schema.beans.PropsDocument.Props target = null; 1274 target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$22, i); 1275 if (target == null) 1276 { 1277 throw new IndexOutOfBoundsException(); 1278 } 1279 return target; 1280 } 1281 } 1282 1283 /** 1284 * Returns number of "props" element 1285 */ 1286 public int sizeOfPropsArray() 1287 { 1288 synchronized (monitor()) 1289 { 1290 check_orphaned(); 1291 return get_store().count_elements(PROPS$22); 1292 } 1293 } 1294 1295 /** 1296 * Sets array of all "props" element 1297 */ 1298 public void setPropsArray(org.springframework.schema.beans.PropsDocument.Props[] propsArray) 1299 { 1300 synchronized (monitor()) 1301 { 1302 check_orphaned(); 1303 arraySetterHelper(propsArray, PROPS$22); 1304 } 1305 } 1306 1307 /** 1308 * Sets ith "props" element 1309 */ 1310 public void setPropsArray(int i, org.springframework.schema.beans.PropsDocument.Props props) 1311 { 1312 synchronized (monitor()) 1313 { 1314 check_orphaned(); 1315 org.springframework.schema.beans.PropsDocument.Props target = null; 1316 target = (org.springframework.schema.beans.PropsDocument.Props)get_store().find_element_user(PROPS$22, i); 1317 if (target == null) 1318 { 1319 throw new IndexOutOfBoundsException(); 1320 } 1321 target.set(props); 1322 } 1323 } 1324 1325 /** 1326 * Inserts and returns a new empty value (as xml) as the ith "props" element 1327 */ 1328 public org.springframework.schema.beans.PropsDocument.Props insertNewProps(int i) 1329 { 1330 synchronized (monitor()) 1331 { 1332 check_orphaned(); 1333 org.springframework.schema.beans.PropsDocument.Props target = null; 1334 target = (org.springframework.schema.beans.PropsDocument.Props)get_store().insert_element_user(PROPS$22, i); 1335 return target; 1336 } 1337 } 1338 1339 /** 1340 * Appends and returns a new empty value (as xml) as the last "props" element 1341 */ 1342 public org.springframework.schema.beans.PropsDocument.Props addNewProps() 1343 { 1344 synchronized (monitor()) 1345 { 1346 check_orphaned(); 1347 org.springframework.schema.beans.PropsDocument.Props target = null; 1348 target = (org.springframework.schema.beans.PropsDocument.Props)get_store().add_element_user(PROPS$22); 1349 return target; 1350 } 1351 } 1352 1353 /** 1354 * Removes the ith "props" element 1355 */ 1356 public void removeProps(int i) 1357 { 1358 synchronized (monitor()) 1359 { 1360 check_orphaned(); 1361 get_store().remove_element(PROPS$22, i); 1362 } 1363 } 1364 1365 /** 1366 * Gets the "key" attribute 1367 */ 1368 public java.lang.String getKey2() 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(KEY2$24); 1375 if (target == null) 1376 { 1377 return null; 1378 } 1379 return target.getStringValue(); 1380 } 1381 } 1382 1383 /** 1384 * Gets (as xml) the "key" attribute 1385 */ 1386 public org.apache.xmlbeans.XmlString xgetKey2() 1387 { 1388 synchronized (monitor()) 1389 { 1390 check_orphaned(); 1391 org.apache.xmlbeans.XmlString target = null; 1392 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEY2$24); 1393 return target; 1394 } 1395 } 1396 1397 /** 1398 * True if has "key" attribute 1399 */ 1400 public boolean isSetKey2() 1401 { 1402 synchronized (monitor()) 1403 { 1404 check_orphaned(); 1405 return get_store().find_attribute_user(KEY2$24) != null; 1406 } 1407 } 1408 1409 /** 1410 * Sets the "key" attribute 1411 */ 1412 public void setKey2(java.lang.String key2) 1413 { 1414 synchronized (monitor()) 1415 { 1416 check_orphaned(); 1417 org.apache.xmlbeans.SimpleValue target = null; 1418 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEY2$24); 1419 if (target == null) 1420 { 1421 target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(KEY2$24); 1422 } 1423 target.setStringValue(key2); 1424 } 1425 } 1426 1427 /** 1428 * Sets (as xml) the "key" attribute 1429 */ 1430 public void xsetKey2(org.apache.xmlbeans.XmlString key2) 1431 { 1432 synchronized (monitor()) 1433 { 1434 check_orphaned(); 1435 org.apache.xmlbeans.XmlString target = null; 1436 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEY2$24); 1437 if (target == null) 1438 { 1439 target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(KEY2$24); 1440 } 1441 target.set(key2); 1442 } 1443 } 1444 1445 /** 1446 * Unsets the "key" attribute 1447 */ 1448 public void unsetKey2() 1449 { 1450 synchronized (monitor()) 1451 { 1452 check_orphaned(); 1453 get_store().remove_attribute(KEY2$24); 1454 } 1455 } 1456 1457 /** 1458 * Gets the "key-ref" attribute 1459 */ 1460 public java.lang.String getKeyRef() 1461 { 1462 synchronized (monitor()) 1463 { 1464 check_orphaned(); 1465 org.apache.xmlbeans.SimpleValue target = null; 1466 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEYREF$26); 1467 if (target == null) 1468 { 1469 return null; 1470 } 1471 return target.getStringValue(); 1472 } 1473 } 1474 1475 /** 1476 * Gets (as xml) the "key-ref" attribute 1477 */ 1478 public org.apache.xmlbeans.XmlString xgetKeyRef() 1479 { 1480 synchronized (monitor()) 1481 { 1482 check_orphaned(); 1483 org.apache.xmlbeans.XmlString target = null; 1484 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEYREF$26); 1485 return target; 1486 } 1487 } 1488 1489 /** 1490 * True if has "key-ref" attribute 1491 */ 1492 public boolean isSetKeyRef() 1493 { 1494 synchronized (monitor()) 1495 { 1496 check_orphaned(); 1497 return get_store().find_attribute_user(KEYREF$26) != null; 1498 } 1499 } 1500 1501 /** 1502 * Sets the "key-ref" attribute 1503 */ 1504 public void setKeyRef(java.lang.String keyRef) 1505 { 1506 synchronized (monitor()) 1507 { 1508 check_orphaned(); 1509 org.apache.xmlbeans.SimpleValue target = null; 1510 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(KEYREF$26); 1511 if (target == null) 1512 { 1513 target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(KEYREF$26); 1514 } 1515 target.setStringValue(keyRef); 1516 } 1517 } 1518 1519 /** 1520 * Sets (as xml) the "key-ref" attribute 1521 */ 1522 public void xsetKeyRef(org.apache.xmlbeans.XmlString keyRef) 1523 { 1524 synchronized (monitor()) 1525 { 1526 check_orphaned(); 1527 org.apache.xmlbeans.XmlString target = null; 1528 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(KEYREF$26); 1529 if (target == null) 1530 { 1531 target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(KEYREF$26); 1532 } 1533 target.set(keyRef); 1534 } 1535 } 1536 1537 /** 1538 * Unsets the "key-ref" attribute 1539 */ 1540 public void unsetKeyRef() 1541 { 1542 synchronized (monitor()) 1543 { 1544 check_orphaned(); 1545 get_store().remove_attribute(KEYREF$26); 1546 } 1547 } 1548 1549 /** 1550 * Gets the "value" attribute 1551 */ 1552 public java.lang.String getValue2() 1553 { 1554 synchronized (monitor()) 1555 { 1556 check_orphaned(); 1557 org.apache.xmlbeans.SimpleValue target = null; 1558 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUE2$28); 1559 if (target == null) 1560 { 1561 return null; 1562 } 1563 return target.getStringValue(); 1564 } 1565 } 1566 1567 /** 1568 * Gets (as xml) the "value" attribute 1569 */ 1570 public org.apache.xmlbeans.XmlString xgetValue2() 1571 { 1572 synchronized (monitor()) 1573 { 1574 check_orphaned(); 1575 org.apache.xmlbeans.XmlString target = null; 1576 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUE2$28); 1577 return target; 1578 } 1579 } 1580 1581 /** 1582 * True if has "value" attribute 1583 */ 1584 public boolean isSetValue2() 1585 { 1586 synchronized (monitor()) 1587 { 1588 check_orphaned(); 1589 return get_store().find_attribute_user(VALUE2$28) != null; 1590 } 1591 } 1592 1593 /** 1594 * Sets the "value" attribute 1595 */ 1596 public void setValue2(java.lang.String value2) 1597 { 1598 synchronized (monitor()) 1599 { 1600 check_orphaned(); 1601 org.apache.xmlbeans.SimpleValue target = null; 1602 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUE2$28); 1603 if (target == null) 1604 { 1605 target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VALUE2$28); 1606 } 1607 target.setStringValue(value2); 1608 } 1609 } 1610 1611 /** 1612 * Sets (as xml) the "value" attribute 1613 */ 1614 public void xsetValue2(org.apache.xmlbeans.XmlString value2) 1615 { 1616 synchronized (monitor()) 1617 { 1618 check_orphaned(); 1619 org.apache.xmlbeans.XmlString target = null; 1620 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUE2$28); 1621 if (target == null) 1622 { 1623 target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(VALUE2$28); 1624 } 1625 target.set(value2); 1626 } 1627 } 1628 1629 /** 1630 * Unsets the "value" attribute 1631 */ 1632 public void unsetValue2() 1633 { 1634 synchronized (monitor()) 1635 { 1636 check_orphaned(); 1637 get_store().remove_attribute(VALUE2$28); 1638 } 1639 } 1640 1641 /** 1642 * Gets the "value-ref" attribute 1643 */ 1644 public java.lang.String getValueRef() 1645 { 1646 synchronized (monitor()) 1647 { 1648 check_orphaned(); 1649 org.apache.xmlbeans.SimpleValue target = null; 1650 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUEREF$30); 1651 if (target == null) 1652 { 1653 return null; 1654 } 1655 return target.getStringValue(); 1656 } 1657 } 1658 1659 /** 1660 * Gets (as xml) the "value-ref" attribute 1661 */ 1662 public org.apache.xmlbeans.XmlString xgetValueRef() 1663 { 1664 synchronized (monitor()) 1665 { 1666 check_orphaned(); 1667 org.apache.xmlbeans.XmlString target = null; 1668 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUEREF$30); 1669 return target; 1670 } 1671 } 1672 1673 /** 1674 * True if has "value-ref" attribute 1675 */ 1676 public boolean isSetValueRef() 1677 { 1678 synchronized (monitor()) 1679 { 1680 check_orphaned(); 1681 return get_store().find_attribute_user(VALUEREF$30) != null; 1682 } 1683 } 1684 1685 /** 1686 * Sets the "value-ref" attribute 1687 */ 1688 public void setValueRef(java.lang.String valueRef) 1689 { 1690 synchronized (monitor()) 1691 { 1692 check_orphaned(); 1693 org.apache.xmlbeans.SimpleValue target = null; 1694 target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(VALUEREF$30); 1695 if (target == null) 1696 { 1697 target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(VALUEREF$30); 1698 } 1699 target.setStringValue(valueRef); 1700 } 1701 } 1702 1703 /** 1704 * Sets (as xml) the "value-ref" attribute 1705 */ 1706 public void xsetValueRef(org.apache.xmlbeans.XmlString valueRef) 1707 { 1708 synchronized (monitor()) 1709 { 1710 check_orphaned(); 1711 org.apache.xmlbeans.XmlString target = null; 1712 target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(VALUEREF$30); 1713 if (target == null) 1714 { 1715 target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(VALUEREF$30); 1716 } 1717 target.set(valueRef); 1718 } 1719 } 1720 1721 /** 1722 * Unsets the "value-ref" attribute 1723 */ 1724 public void unsetValueRef() 1725 { 1726 synchronized (monitor()) 1727 { 1728 check_orphaned(); 1729 get_store().remove_attribute(VALUEREF$30); 1730 } 1731 } 1732}