001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v22.message; 035 036import ca.uhn.hl7v2.model.v22.group.*; 037import ca.uhn.hl7v2.model.v22.segment.*; 038 039import ca.uhn.hl7v2.HL7Exception; 040import ca.uhn.hl7v2.parser.ModelClassFactory; 041import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 042import ca.uhn.hl7v2.model.*; 043 044 045/** 046 * <p>Represents a ADT_A06 message structure (see chapter ?). This structure contains the 047 * following elements: </p> 048 * <ul> 049 * <li>1: MSH (MESSAGE HEADER) <b> </b> </li> 050 * <li>2: EVN (EVENT TYPE) <b> </b> </li> 051 * <li>3: PID (PATIENT IDENTIFICATION) <b> </b> </li> 052 * <li>4: MRG (MERGE PATIENT INFORMATION) <b>optional </b> </li> 053 * <li>5: NK1 (NEXT OF KIN) <b>optional repeating</b> </li> 054 * <li>6: PV1 (PATIENT VISIT) <b> </b> </li> 055 * <li>7: PV2 (PATIENT VISIT - additional information) <b>optional </b> </li> 056 * <li>8: OBX (OBSERVATION RESULT) <b>optional repeating</b> </li> 057 * <li>9: AL1 (PATIENT ALLERGY INFORMATION) <b>optional repeating</b> </li> 058 * <li>10: DG1 (DIAGNOSIS) <b>optional repeating</b> </li> 059 * <li>11: PR1 (PROCEDURES) <b>optional repeating</b> </li> 060 * <li>12: GT1 (GUARANTOR) <b>optional repeating</b> </li> 061 * <li>13: ADT_A06_INSURANCE (a Group object) <b>optional repeating</b> </li> 062 * <li>14: ACC (ACCIDENT) <b>optional </b> </li> 063 * <li>15: UB1 (UB82 DATA) <b>optional </b> </li> 064 * <li>16: UB2 (UB92 DATA) <b>optional </b> </li> 065 * </ul> 066 */ 067//@SuppressWarnings("unused") 068public class ADT_A06 extends AbstractMessage { 069 070 /** 071 * Creates a new ADT_A06 message with DefaultModelClassFactory. 072 */ 073 public ADT_A06() { 074 this(new DefaultModelClassFactory()); 075 } 076 077 /** 078 * Creates a new ADT_A06 message with custom ModelClassFactory. 079 */ 080 public ADT_A06(ModelClassFactory factory) { 081 super(factory); 082 init(factory); 083 } 084 085 private void init(ModelClassFactory factory) { 086 try { 087 this.add(MSH.class, true, false); 088 this.add(EVN.class, true, false); 089 this.add(PID.class, true, false); 090 this.add(MRG.class, false, false); 091 this.add(NK1.class, false, true); 092 this.add(PV1.class, true, false); 093 this.add(PV2.class, false, false); 094 this.add(OBX.class, false, true); 095 this.add(AL1.class, false, true); 096 this.add(DG1.class, false, true); 097 this.add(PR1.class, false, true); 098 this.add(GT1.class, false, true); 099 this.add(ADT_A06_INSURANCE.class, false, true); 100 this.add(ACC.class, false, false); 101 this.add(UB1.class, false, false); 102 this.add(UB2.class, false, false); 103 } catch(HL7Exception e) { 104 log.error("Unexpected error creating ADT_A06 - this is probably a bug in the source code generator.", e); 105 } 106 } 107 108 109 /** 110 * Returns "2.2" 111 */ 112 public String getVersion() { 113 return "2.2"; 114 } 115 116 117 118 119 /** 120 * <p> 121 * Returns 122 * MSH (MESSAGE HEADER) - creates it if necessary 123 * </p> 124 * 125 * 126 */ 127 public MSH getMSH() { 128 return getTyped("MSH", MSH.class); 129 } 130 131 132 133 134 135 /** 136 * <p> 137 * Returns 138 * EVN (EVENT TYPE) - creates it if necessary 139 * </p> 140 * 141 * 142 */ 143 public EVN getEVN() { 144 return getTyped("EVN", EVN.class); 145 } 146 147 148 149 150 151 /** 152 * <p> 153 * Returns 154 * PID (PATIENT IDENTIFICATION) - creates it if necessary 155 * </p> 156 * 157 * 158 */ 159 public PID getPID() { 160 return getTyped("PID", PID.class); 161 } 162 163 164 165 166 167 /** 168 * <p> 169 * Returns 170 * MRG (MERGE PATIENT INFORMATION) - creates it if necessary 171 * </p> 172 * 173 * 174 */ 175 public MRG getMRG() { 176 return getTyped("MRG", MRG.class); 177 } 178 179 180 181 182 183 /** 184 * <p> 185 * Returns 186 * the first repetition of 187 * NK1 (NEXT OF KIN) - creates it if necessary 188 * </p> 189 * 190 * 191 */ 192 public NK1 getNK1() { 193 return getTyped("NK1", NK1.class); 194 } 195 196 197 /** 198 * <p> 199 * Returns a specific repetition of 200 * NK1 (NEXT OF KIN) - creates it if necessary 201 * </p> 202 * 203 * 204 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 205 * @throws HL7Exception if the repetition requested is more than one 206 * greater than the number of existing repetitions. 207 */ 208 public NK1 getNK1(int rep) { 209 return getTyped("NK1", rep, NK1.class); 210 } 211 212 /** 213 * <p> 214 * Returns the number of existing repetitions of NK1 215 * </p> 216 * 217 */ 218 public int getNK1Reps() { 219 return getReps("NK1"); 220 } 221 222 /** 223 * <p> 224 * Returns a non-modifiable List containing all current existing repetitions of NK1. 225 * <p> 226 * <p> 227 * Note that unlike {@link #getNK1()}, this method will not create any reps 228 * if none are already present, so an empty list may be returned. 229 * </p> 230 * 231 */ 232 public java.util.List<NK1> getNK1All() throws HL7Exception { 233 return getAllAsList("NK1", NK1.class); 234 } 235 236 /** 237 * <p> 238 * Inserts a specific repetition of NK1 (NEXT OF KIN) 239 * </p> 240 * 241 * 242 * @see AbstractGroup#insertRepetition(Structure, int) 243 */ 244 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 245 super.insertRepetition( "NK1", structure, rep); 246 } 247 248 249 /** 250 * <p> 251 * Inserts a specific repetition of NK1 (NEXT OF KIN) 252 * </p> 253 * 254 * 255 * @see AbstractGroup#insertRepetition(Structure, int) 256 */ 257 public NK1 insertNK1(int rep) throws HL7Exception { 258 return (NK1)super.insertRepetition("NK1", rep); 259 } 260 261 262 /** 263 * <p> 264 * Removes a specific repetition of NK1 (NEXT OF KIN) 265 * </p> 266 * 267 * 268 * @see AbstractGroup#removeRepetition(String, int) 269 */ 270 public NK1 removeNK1(int rep) throws HL7Exception { 271 return (NK1)super.removeRepetition("NK1", rep); 272 } 273 274 275 276 277 /** 278 * <p> 279 * Returns 280 * PV1 (PATIENT VISIT) - creates it if necessary 281 * </p> 282 * 283 * 284 */ 285 public PV1 getPV1() { 286 return getTyped("PV1", PV1.class); 287 } 288 289 290 291 292 293 /** 294 * <p> 295 * Returns 296 * PV2 (PATIENT VISIT - additional information) - creates it if necessary 297 * </p> 298 * 299 * 300 */ 301 public PV2 getPV2() { 302 return getTyped("PV2", PV2.class); 303 } 304 305 306 307 308 309 /** 310 * <p> 311 * Returns 312 * the first repetition of 313 * OBX (OBSERVATION RESULT) - creates it if necessary 314 * </p> 315 * 316 * 317 */ 318 public OBX getOBX() { 319 return getTyped("OBX", OBX.class); 320 } 321 322 323 /** 324 * <p> 325 * Returns a specific repetition of 326 * OBX (OBSERVATION RESULT) - creates it if necessary 327 * </p> 328 * 329 * 330 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 331 * @throws HL7Exception if the repetition requested is more than one 332 * greater than the number of existing repetitions. 333 */ 334 public OBX getOBX(int rep) { 335 return getTyped("OBX", rep, OBX.class); 336 } 337 338 /** 339 * <p> 340 * Returns the number of existing repetitions of OBX 341 * </p> 342 * 343 */ 344 public int getOBXReps() { 345 return getReps("OBX"); 346 } 347 348 /** 349 * <p> 350 * Returns a non-modifiable List containing all current existing repetitions of OBX. 351 * <p> 352 * <p> 353 * Note that unlike {@link #getOBX()}, this method will not create any reps 354 * if none are already present, so an empty list may be returned. 355 * </p> 356 * 357 */ 358 public java.util.List<OBX> getOBXAll() throws HL7Exception { 359 return getAllAsList("OBX", OBX.class); 360 } 361 362 /** 363 * <p> 364 * Inserts a specific repetition of OBX (OBSERVATION RESULT) 365 * </p> 366 * 367 * 368 * @see AbstractGroup#insertRepetition(Structure, int) 369 */ 370 public void insertOBX(OBX structure, int rep) throws HL7Exception { 371 super.insertRepetition( "OBX", structure, rep); 372 } 373 374 375 /** 376 * <p> 377 * Inserts a specific repetition of OBX (OBSERVATION RESULT) 378 * </p> 379 * 380 * 381 * @see AbstractGroup#insertRepetition(Structure, int) 382 */ 383 public OBX insertOBX(int rep) throws HL7Exception { 384 return (OBX)super.insertRepetition("OBX", rep); 385 } 386 387 388 /** 389 * <p> 390 * Removes a specific repetition of OBX (OBSERVATION RESULT) 391 * </p> 392 * 393 * 394 * @see AbstractGroup#removeRepetition(String, int) 395 */ 396 public OBX removeOBX(int rep) throws HL7Exception { 397 return (OBX)super.removeRepetition("OBX", rep); 398 } 399 400 401 402 403 /** 404 * <p> 405 * Returns 406 * the first repetition of 407 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary 408 * </p> 409 * 410 * 411 */ 412 public AL1 getAL1() { 413 return getTyped("AL1", AL1.class); 414 } 415 416 417 /** 418 * <p> 419 * Returns a specific repetition of 420 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary 421 * </p> 422 * 423 * 424 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 425 * @throws HL7Exception if the repetition requested is more than one 426 * greater than the number of existing repetitions. 427 */ 428 public AL1 getAL1(int rep) { 429 return getTyped("AL1", rep, AL1.class); 430 } 431 432 /** 433 * <p> 434 * Returns the number of existing repetitions of AL1 435 * </p> 436 * 437 */ 438 public int getAL1Reps() { 439 return getReps("AL1"); 440 } 441 442 /** 443 * <p> 444 * Returns a non-modifiable List containing all current existing repetitions of AL1. 445 * <p> 446 * <p> 447 * Note that unlike {@link #getAL1()}, this method will not create any reps 448 * if none are already present, so an empty list may be returned. 449 * </p> 450 * 451 */ 452 public java.util.List<AL1> getAL1All() throws HL7Exception { 453 return getAllAsList("AL1", AL1.class); 454 } 455 456 /** 457 * <p> 458 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION) 459 * </p> 460 * 461 * 462 * @see AbstractGroup#insertRepetition(Structure, int) 463 */ 464 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 465 super.insertRepetition( "AL1", structure, rep); 466 } 467 468 469 /** 470 * <p> 471 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION) 472 * </p> 473 * 474 * 475 * @see AbstractGroup#insertRepetition(Structure, int) 476 */ 477 public AL1 insertAL1(int rep) throws HL7Exception { 478 return (AL1)super.insertRepetition("AL1", rep); 479 } 480 481 482 /** 483 * <p> 484 * Removes a specific repetition of AL1 (PATIENT ALLERGY INFORMATION) 485 * </p> 486 * 487 * 488 * @see AbstractGroup#removeRepetition(String, int) 489 */ 490 public AL1 removeAL1(int rep) throws HL7Exception { 491 return (AL1)super.removeRepetition("AL1", rep); 492 } 493 494 495 496 497 /** 498 * <p> 499 * Returns 500 * the first repetition of 501 * DG1 (DIAGNOSIS) - creates it if necessary 502 * </p> 503 * 504 * 505 */ 506 public DG1 getDG1() { 507 return getTyped("DG1", DG1.class); 508 } 509 510 511 /** 512 * <p> 513 * Returns a specific repetition of 514 * DG1 (DIAGNOSIS) - creates it if necessary 515 * </p> 516 * 517 * 518 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 519 * @throws HL7Exception if the repetition requested is more than one 520 * greater than the number of existing repetitions. 521 */ 522 public DG1 getDG1(int rep) { 523 return getTyped("DG1", rep, DG1.class); 524 } 525 526 /** 527 * <p> 528 * Returns the number of existing repetitions of DG1 529 * </p> 530 * 531 */ 532 public int getDG1Reps() { 533 return getReps("DG1"); 534 } 535 536 /** 537 * <p> 538 * Returns a non-modifiable List containing all current existing repetitions of DG1. 539 * <p> 540 * <p> 541 * Note that unlike {@link #getDG1()}, this method will not create any reps 542 * if none are already present, so an empty list may be returned. 543 * </p> 544 * 545 */ 546 public java.util.List<DG1> getDG1All() throws HL7Exception { 547 return getAllAsList("DG1", DG1.class); 548 } 549 550 /** 551 * <p> 552 * Inserts a specific repetition of DG1 (DIAGNOSIS) 553 * </p> 554 * 555 * 556 * @see AbstractGroup#insertRepetition(Structure, int) 557 */ 558 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 559 super.insertRepetition( "DG1", structure, rep); 560 } 561 562 563 /** 564 * <p> 565 * Inserts a specific repetition of DG1 (DIAGNOSIS) 566 * </p> 567 * 568 * 569 * @see AbstractGroup#insertRepetition(Structure, int) 570 */ 571 public DG1 insertDG1(int rep) throws HL7Exception { 572 return (DG1)super.insertRepetition("DG1", rep); 573 } 574 575 576 /** 577 * <p> 578 * Removes a specific repetition of DG1 (DIAGNOSIS) 579 * </p> 580 * 581 * 582 * @see AbstractGroup#removeRepetition(String, int) 583 */ 584 public DG1 removeDG1(int rep) throws HL7Exception { 585 return (DG1)super.removeRepetition("DG1", rep); 586 } 587 588 589 590 591 /** 592 * <p> 593 * Returns 594 * the first repetition of 595 * PR1 (PROCEDURES) - creates it if necessary 596 * </p> 597 * 598 * 599 */ 600 public PR1 getPR1() { 601 return getTyped("PR1", PR1.class); 602 } 603 604 605 /** 606 * <p> 607 * Returns a specific repetition of 608 * PR1 (PROCEDURES) - creates it if necessary 609 * </p> 610 * 611 * 612 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 613 * @throws HL7Exception if the repetition requested is more than one 614 * greater than the number of existing repetitions. 615 */ 616 public PR1 getPR1(int rep) { 617 return getTyped("PR1", rep, PR1.class); 618 } 619 620 /** 621 * <p> 622 * Returns the number of existing repetitions of PR1 623 * </p> 624 * 625 */ 626 public int getPR1Reps() { 627 return getReps("PR1"); 628 } 629 630 /** 631 * <p> 632 * Returns a non-modifiable List containing all current existing repetitions of PR1. 633 * <p> 634 * <p> 635 * Note that unlike {@link #getPR1()}, this method will not create any reps 636 * if none are already present, so an empty list may be returned. 637 * </p> 638 * 639 */ 640 public java.util.List<PR1> getPR1All() throws HL7Exception { 641 return getAllAsList("PR1", PR1.class); 642 } 643 644 /** 645 * <p> 646 * Inserts a specific repetition of PR1 (PROCEDURES) 647 * </p> 648 * 649 * 650 * @see AbstractGroup#insertRepetition(Structure, int) 651 */ 652 public void insertPR1(PR1 structure, int rep) throws HL7Exception { 653 super.insertRepetition( "PR1", structure, rep); 654 } 655 656 657 /** 658 * <p> 659 * Inserts a specific repetition of PR1 (PROCEDURES) 660 * </p> 661 * 662 * 663 * @see AbstractGroup#insertRepetition(Structure, int) 664 */ 665 public PR1 insertPR1(int rep) throws HL7Exception { 666 return (PR1)super.insertRepetition("PR1", rep); 667 } 668 669 670 /** 671 * <p> 672 * Removes a specific repetition of PR1 (PROCEDURES) 673 * </p> 674 * 675 * 676 * @see AbstractGroup#removeRepetition(String, int) 677 */ 678 public PR1 removePR1(int rep) throws HL7Exception { 679 return (PR1)super.removeRepetition("PR1", rep); 680 } 681 682 683 684 685 /** 686 * <p> 687 * Returns 688 * the first repetition of 689 * GT1 (GUARANTOR) - creates it if necessary 690 * </p> 691 * 692 * 693 */ 694 public GT1 getGT1() { 695 return getTyped("GT1", GT1.class); 696 } 697 698 699 /** 700 * <p> 701 * Returns a specific repetition of 702 * GT1 (GUARANTOR) - creates it if necessary 703 * </p> 704 * 705 * 706 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 707 * @throws HL7Exception if the repetition requested is more than one 708 * greater than the number of existing repetitions. 709 */ 710 public GT1 getGT1(int rep) { 711 return getTyped("GT1", rep, GT1.class); 712 } 713 714 /** 715 * <p> 716 * Returns the number of existing repetitions of GT1 717 * </p> 718 * 719 */ 720 public int getGT1Reps() { 721 return getReps("GT1"); 722 } 723 724 /** 725 * <p> 726 * Returns a non-modifiable List containing all current existing repetitions of GT1. 727 * <p> 728 * <p> 729 * Note that unlike {@link #getGT1()}, this method will not create any reps 730 * if none are already present, so an empty list may be returned. 731 * </p> 732 * 733 */ 734 public java.util.List<GT1> getGT1All() throws HL7Exception { 735 return getAllAsList("GT1", GT1.class); 736 } 737 738 /** 739 * <p> 740 * Inserts a specific repetition of GT1 (GUARANTOR) 741 * </p> 742 * 743 * 744 * @see AbstractGroup#insertRepetition(Structure, int) 745 */ 746 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 747 super.insertRepetition( "GT1", structure, rep); 748 } 749 750 751 /** 752 * <p> 753 * Inserts a specific repetition of GT1 (GUARANTOR) 754 * </p> 755 * 756 * 757 * @see AbstractGroup#insertRepetition(Structure, int) 758 */ 759 public GT1 insertGT1(int rep) throws HL7Exception { 760 return (GT1)super.insertRepetition("GT1", rep); 761 } 762 763 764 /** 765 * <p> 766 * Removes a specific repetition of GT1 (GUARANTOR) 767 * </p> 768 * 769 * 770 * @see AbstractGroup#removeRepetition(String, int) 771 */ 772 public GT1 removeGT1(int rep) throws HL7Exception { 773 return (GT1)super.removeRepetition("GT1", rep); 774 } 775 776 777 778 779 /** 780 * <p> 781 * Returns 782 * the first repetition of 783 * INSURANCE (a Group object) - creates it if necessary 784 * </p> 785 * 786 * 787 */ 788 public ADT_A06_INSURANCE getINSURANCE() { 789 return getTyped("INSURANCE", ADT_A06_INSURANCE.class); 790 } 791 792 793 /** 794 * <p> 795 * Returns a specific repetition of 796 * INSURANCE (a Group object) - creates it if necessary 797 * </p> 798 * 799 * 800 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 801 * @throws HL7Exception if the repetition requested is more than one 802 * greater than the number of existing repetitions. 803 */ 804 public ADT_A06_INSURANCE getINSURANCE(int rep) { 805 return getTyped("INSURANCE", rep, ADT_A06_INSURANCE.class); 806 } 807 808 /** 809 * <p> 810 * Returns the number of existing repetitions of INSURANCE 811 * </p> 812 * 813 */ 814 public int getINSURANCEReps() { 815 return getReps("INSURANCE"); 816 } 817 818 /** 819 * <p> 820 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 821 * <p> 822 * <p> 823 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 824 * if none are already present, so an empty list may be returned. 825 * </p> 826 * 827 */ 828 public java.util.List<ADT_A06_INSURANCE> getINSURANCEAll() throws HL7Exception { 829 return getAllAsList("INSURANCE", ADT_A06_INSURANCE.class); 830 } 831 832 /** 833 * <p> 834 * Inserts a specific repetition of INSURANCE (a Group object) 835 * </p> 836 * 837 * 838 * @see AbstractGroup#insertRepetition(Structure, int) 839 */ 840 public void insertINSURANCE(ADT_A06_INSURANCE structure, int rep) throws HL7Exception { 841 super.insertRepetition( "INSURANCE", structure, rep); 842 } 843 844 845 /** 846 * <p> 847 * Inserts a specific repetition of INSURANCE (a Group object) 848 * </p> 849 * 850 * 851 * @see AbstractGroup#insertRepetition(Structure, int) 852 */ 853 public ADT_A06_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 854 return (ADT_A06_INSURANCE)super.insertRepetition("INSURANCE", rep); 855 } 856 857 858 /** 859 * <p> 860 * Removes a specific repetition of INSURANCE (a Group object) 861 * </p> 862 * 863 * 864 * @see AbstractGroup#removeRepetition(String, int) 865 */ 866 public ADT_A06_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 867 return (ADT_A06_INSURANCE)super.removeRepetition("INSURANCE", rep); 868 } 869 870 871 872 873 /** 874 * <p> 875 * Returns 876 * ACC (ACCIDENT) - creates it if necessary 877 * </p> 878 * 879 * 880 */ 881 public ACC getACC() { 882 return getTyped("ACC", ACC.class); 883 } 884 885 886 887 888 889 /** 890 * <p> 891 * Returns 892 * UB1 (UB82 DATA) - creates it if necessary 893 * </p> 894 * 895 * 896 */ 897 public UB1 getUB1() { 898 return getTyped("UB1", UB1.class); 899 } 900 901 902 903 904 905 /** 906 * <p> 907 * Returns 908 * UB2 (UB92 DATA) - creates it if necessary 909 * </p> 910 * 911 * 912 */ 913 public UB2 getUB2() { 914 return getTyped("UB2", UB2.class); 915 } 916 917 918 919 920} 921