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.v23.group; 035 036import ca.uhn.hl7v2.model.v23.segment.*; 037 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.model.*; 041 042/** 043 * <p>Represents a ADR_A19_QUERY_RESPONSE group structure (a Group object). 044 * A Group is an ordered collection of message segments that can repeat together or be optionally in/excluded together. 045 * This Group contains the following elements: 046 * </p> 047 * <ul> 048 * <li>1: EVN (Event type) <b>optional </b></li> 049 * <li>2: PID (Patient Identification) <b> </b></li> 050 * <li>3: PD1 (Patient Demographic) <b>optional </b></li> 051 * <li>4: NK1 (Next of kin) <b>optional repeating </b></li> 052 * <li>5: PV1 (Patient visit) <b> </b></li> 053 * <li>6: PV2 (Patient visit - additional information) <b>optional </b></li> 054 * <li>7: DB1 (Disability Segment) <b>optional repeating </b></li> 055 * <li>8: OBX (Observation segment) <b>optional repeating </b></li> 056 * <li>9: AL1 (Patient allergy information) <b>optional repeating </b></li> 057 * <li>10: DG1 (Diagnosis) <b>optional repeating </b></li> 058 * <li>11: DRG (Diagnosis Related Group) <b>optional </b></li> 059 * <li>12: ADR_A19_PROCEDURE (a Group object) <b>optional repeating </b></li> 060 * <li>13: GT1 (Guarantor) <b>optional repeating </b></li> 061 * <li>14: ADR_A19_INSURANCE (a Group object) <b>optional repeating </b></li> 062 * <li>15: ACC (Accident) <b>optional </b></li> 063 * <li>16: UB1 (UB82 data) <b>optional </b></li> 064 * <li>17: UB2 (UB92 data) <b>optional </b></li> 065 * </ul> 066 */ 067//@SuppressWarnings("unused") 068public class ADR_A19_QUERY_RESPONSE extends AbstractGroup { 069 070 /** 071 * Creates a new ADR_A19_QUERY_RESPONSE group 072 */ 073 public ADR_A19_QUERY_RESPONSE(Group parent, ModelClassFactory factory) { 074 super(parent, factory); 075 init(factory); 076 } 077 078 private void init(ModelClassFactory factory) { 079 try { 080 this.add(EVN.class, false, false, false); 081 this.add(PID.class, true, false, false); 082 this.add(PD1.class, false, false, false); 083 this.add(NK1.class, false, true, false); 084 this.add(PV1.class, true, false, false); 085 this.add(PV2.class, false, false, false); 086 this.add(DB1.class, false, true, false); 087 this.add(OBX.class, false, true, false); 088 this.add(AL1.class, false, true, false); 089 this.add(DG1.class, false, true, false); 090 this.add(DRG.class, false, false, false); 091 this.add(ADR_A19_PROCEDURE.class, false, true, false); 092 this.add(GT1.class, false, true, false); 093 this.add(ADR_A19_INSURANCE.class, false, true, false); 094 this.add(ACC.class, false, false, false); 095 this.add(UB1.class, false, false, false); 096 this.add(UB2.class, false, false, false); 097 } catch(HL7Exception e) { 098 log.error("Unexpected error creating ADR_A19_QUERY_RESPONSE - this is probably a bug in the source code generator.", e); 099 } 100 } 101 102 /** 103 * Returns "2.3" 104 */ 105 public String getVersion() { 106 return "2.3"; 107 } 108 109 110 111 /** 112 * Returns 113 * EVN (Event type) - creates it if necessary 114 */ 115 public EVN getEVN() { 116 EVN retVal = getTyped("EVN", EVN.class); 117 return retVal; 118 } 119 120 121 122 123 /** 124 * Returns 125 * PID (Patient Identification) - creates it if necessary 126 */ 127 public PID getPID() { 128 PID retVal = getTyped("PID", PID.class); 129 return retVal; 130 } 131 132 133 134 135 /** 136 * Returns 137 * PD1 (Patient Demographic) - creates it if necessary 138 */ 139 public PD1 getPD1() { 140 PD1 retVal = getTyped("PD1", PD1.class); 141 return retVal; 142 } 143 144 145 146 147 /** 148 * Returns 149 * the first repetition of 150 * NK1 (Next of kin) - creates it if necessary 151 */ 152 public NK1 getNK1() { 153 NK1 retVal = getTyped("NK1", NK1.class); 154 return retVal; 155 } 156 157 158 /** 159 * Returns a specific repetition of 160 * NK1 (Next of kin) - creates it if necessary 161 * 162 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 163 * @throws HL7Exception if the repetition requested is more than one 164 * greater than the number of existing repetitions. 165 */ 166 public NK1 getNK1(int rep) { 167 NK1 retVal = getTyped("NK1", rep, NK1.class); 168 return retVal; 169 } 170 171 /** 172 * Returns the number of existing repetitions of NK1 173 */ 174 public int getNK1Reps() { 175 return getReps("NK1"); 176 } 177 178 /** 179 * <p> 180 * Returns a non-modifiable List containing all current existing repetitions of NK1. 181 * <p> 182 * <p> 183 * Note that unlike {@link #getNK1()}, this method will not create any reps 184 * if none are already present, so an empty list may be returned. 185 * </p> 186 */ 187 public java.util.List<NK1> getNK1All() throws HL7Exception { 188 return getAllAsList("NK1", NK1.class); 189 } 190 191 /** 192 * Inserts a specific repetition of NK1 (Next of kin) 193 * @see AbstractGroup#insertRepetition(Structure, int) 194 */ 195 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 196 super.insertRepetition("NK1", structure, rep); 197 } 198 199 200 /** 201 * Inserts a specific repetition of NK1 (Next of kin) 202 * @see AbstractGroup#insertRepetition(Structure, int) 203 */ 204 public NK1 insertNK1(int rep) throws HL7Exception { 205 return (NK1)super.insertRepetition("NK1", rep); 206 } 207 208 209 /** 210 * Removes a specific repetition of NK1 (Next of kin) 211 * @see AbstractGroup#removeRepetition(String, int) 212 */ 213 public NK1 removeNK1(int rep) throws HL7Exception { 214 return (NK1)super.removeRepetition("NK1", rep); 215 } 216 217 218 219 /** 220 * Returns 221 * PV1 (Patient visit) - creates it if necessary 222 */ 223 public PV1 getPV1() { 224 PV1 retVal = getTyped("PV1", PV1.class); 225 return retVal; 226 } 227 228 229 230 231 /** 232 * Returns 233 * PV2 (Patient visit - additional information) - creates it if necessary 234 */ 235 public PV2 getPV2() { 236 PV2 retVal = getTyped("PV2", PV2.class); 237 return retVal; 238 } 239 240 241 242 243 /** 244 * Returns 245 * the first repetition of 246 * DB1 (Disability Segment) - creates it if necessary 247 */ 248 public DB1 getDB1() { 249 DB1 retVal = getTyped("DB1", DB1.class); 250 return retVal; 251 } 252 253 254 /** 255 * Returns a specific repetition of 256 * DB1 (Disability Segment) - creates it if necessary 257 * 258 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 259 * @throws HL7Exception if the repetition requested is more than one 260 * greater than the number of existing repetitions. 261 */ 262 public DB1 getDB1(int rep) { 263 DB1 retVal = getTyped("DB1", rep, DB1.class); 264 return retVal; 265 } 266 267 /** 268 * Returns the number of existing repetitions of DB1 269 */ 270 public int getDB1Reps() { 271 return getReps("DB1"); 272 } 273 274 /** 275 * <p> 276 * Returns a non-modifiable List containing all current existing repetitions of DB1. 277 * <p> 278 * <p> 279 * Note that unlike {@link #getDB1()}, this method will not create any reps 280 * if none are already present, so an empty list may be returned. 281 * </p> 282 */ 283 public java.util.List<DB1> getDB1All() throws HL7Exception { 284 return getAllAsList("DB1", DB1.class); 285 } 286 287 /** 288 * Inserts a specific repetition of DB1 (Disability Segment) 289 * @see AbstractGroup#insertRepetition(Structure, int) 290 */ 291 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 292 super.insertRepetition("DB1", structure, rep); 293 } 294 295 296 /** 297 * Inserts a specific repetition of DB1 (Disability Segment) 298 * @see AbstractGroup#insertRepetition(Structure, int) 299 */ 300 public DB1 insertDB1(int rep) throws HL7Exception { 301 return (DB1)super.insertRepetition("DB1", rep); 302 } 303 304 305 /** 306 * Removes a specific repetition of DB1 (Disability Segment) 307 * @see AbstractGroup#removeRepetition(String, int) 308 */ 309 public DB1 removeDB1(int rep) throws HL7Exception { 310 return (DB1)super.removeRepetition("DB1", rep); 311 } 312 313 314 315 /** 316 * Returns 317 * the first repetition of 318 * OBX (Observation segment) - creates it if necessary 319 */ 320 public OBX getOBX() { 321 OBX retVal = getTyped("OBX", OBX.class); 322 return retVal; 323 } 324 325 326 /** 327 * Returns a specific repetition of 328 * OBX (Observation segment) - creates it if necessary 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 OBX retVal = getTyped("OBX", rep, OBX.class); 336 return retVal; 337 } 338 339 /** 340 * Returns the number of existing repetitions of OBX 341 */ 342 public int getOBXReps() { 343 return getReps("OBX"); 344 } 345 346 /** 347 * <p> 348 * Returns a non-modifiable List containing all current existing repetitions of OBX. 349 * <p> 350 * <p> 351 * Note that unlike {@link #getOBX()}, this method will not create any reps 352 * if none are already present, so an empty list may be returned. 353 * </p> 354 */ 355 public java.util.List<OBX> getOBXAll() throws HL7Exception { 356 return getAllAsList("OBX", OBX.class); 357 } 358 359 /** 360 * Inserts a specific repetition of OBX (Observation segment) 361 * @see AbstractGroup#insertRepetition(Structure, int) 362 */ 363 public void insertOBX(OBX structure, int rep) throws HL7Exception { 364 super.insertRepetition("OBX", structure, rep); 365 } 366 367 368 /** 369 * Inserts a specific repetition of OBX (Observation segment) 370 * @see AbstractGroup#insertRepetition(Structure, int) 371 */ 372 public OBX insertOBX(int rep) throws HL7Exception { 373 return (OBX)super.insertRepetition("OBX", rep); 374 } 375 376 377 /** 378 * Removes a specific repetition of OBX (Observation segment) 379 * @see AbstractGroup#removeRepetition(String, int) 380 */ 381 public OBX removeOBX(int rep) throws HL7Exception { 382 return (OBX)super.removeRepetition("OBX", rep); 383 } 384 385 386 387 /** 388 * Returns 389 * the first repetition of 390 * AL1 (Patient allergy information) - creates it if necessary 391 */ 392 public AL1 getAL1() { 393 AL1 retVal = getTyped("AL1", AL1.class); 394 return retVal; 395 } 396 397 398 /** 399 * Returns a specific repetition of 400 * AL1 (Patient allergy information) - creates it if necessary 401 * 402 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 403 * @throws HL7Exception if the repetition requested is more than one 404 * greater than the number of existing repetitions. 405 */ 406 public AL1 getAL1(int rep) { 407 AL1 retVal = getTyped("AL1", rep, AL1.class); 408 return retVal; 409 } 410 411 /** 412 * Returns the number of existing repetitions of AL1 413 */ 414 public int getAL1Reps() { 415 return getReps("AL1"); 416 } 417 418 /** 419 * <p> 420 * Returns a non-modifiable List containing all current existing repetitions of AL1. 421 * <p> 422 * <p> 423 * Note that unlike {@link #getAL1()}, this method will not create any reps 424 * if none are already present, so an empty list may be returned. 425 * </p> 426 */ 427 public java.util.List<AL1> getAL1All() throws HL7Exception { 428 return getAllAsList("AL1", AL1.class); 429 } 430 431 /** 432 * Inserts a specific repetition of AL1 (Patient allergy information) 433 * @see AbstractGroup#insertRepetition(Structure, int) 434 */ 435 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 436 super.insertRepetition("AL1", structure, rep); 437 } 438 439 440 /** 441 * Inserts a specific repetition of AL1 (Patient allergy information) 442 * @see AbstractGroup#insertRepetition(Structure, int) 443 */ 444 public AL1 insertAL1(int rep) throws HL7Exception { 445 return (AL1)super.insertRepetition("AL1", rep); 446 } 447 448 449 /** 450 * Removes a specific repetition of AL1 (Patient allergy information) 451 * @see AbstractGroup#removeRepetition(String, int) 452 */ 453 public AL1 removeAL1(int rep) throws HL7Exception { 454 return (AL1)super.removeRepetition("AL1", rep); 455 } 456 457 458 459 /** 460 * Returns 461 * the first repetition of 462 * DG1 (Diagnosis) - creates it if necessary 463 */ 464 public DG1 getDG1() { 465 DG1 retVal = getTyped("DG1", DG1.class); 466 return retVal; 467 } 468 469 470 /** 471 * Returns a specific repetition of 472 * DG1 (Diagnosis) - creates it if necessary 473 * 474 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 475 * @throws HL7Exception if the repetition requested is more than one 476 * greater than the number of existing repetitions. 477 */ 478 public DG1 getDG1(int rep) { 479 DG1 retVal = getTyped("DG1", rep, DG1.class); 480 return retVal; 481 } 482 483 /** 484 * Returns the number of existing repetitions of DG1 485 */ 486 public int getDG1Reps() { 487 return getReps("DG1"); 488 } 489 490 /** 491 * <p> 492 * Returns a non-modifiable List containing all current existing repetitions of DG1. 493 * <p> 494 * <p> 495 * Note that unlike {@link #getDG1()}, this method will not create any reps 496 * if none are already present, so an empty list may be returned. 497 * </p> 498 */ 499 public java.util.List<DG1> getDG1All() throws HL7Exception { 500 return getAllAsList("DG1", DG1.class); 501 } 502 503 /** 504 * Inserts a specific repetition of DG1 (Diagnosis) 505 * @see AbstractGroup#insertRepetition(Structure, int) 506 */ 507 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 508 super.insertRepetition("DG1", structure, rep); 509 } 510 511 512 /** 513 * Inserts a specific repetition of DG1 (Diagnosis) 514 * @see AbstractGroup#insertRepetition(Structure, int) 515 */ 516 public DG1 insertDG1(int rep) throws HL7Exception { 517 return (DG1)super.insertRepetition("DG1", rep); 518 } 519 520 521 /** 522 * Removes a specific repetition of DG1 (Diagnosis) 523 * @see AbstractGroup#removeRepetition(String, int) 524 */ 525 public DG1 removeDG1(int rep) throws HL7Exception { 526 return (DG1)super.removeRepetition("DG1", rep); 527 } 528 529 530 531 /** 532 * Returns 533 * DRG (Diagnosis Related Group) - creates it if necessary 534 */ 535 public DRG getDRG() { 536 DRG retVal = getTyped("DRG", DRG.class); 537 return retVal; 538 } 539 540 541 542 543 /** 544 * Returns 545 * the first repetition of 546 * PROCEDURE (a Group object) - creates it if necessary 547 */ 548 public ADR_A19_PROCEDURE getPROCEDURE() { 549 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", ADR_A19_PROCEDURE.class); 550 return retVal; 551 } 552 553 554 /** 555 * Returns a specific repetition of 556 * PROCEDURE (a Group object) - creates it if necessary 557 * 558 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 559 * @throws HL7Exception if the repetition requested is more than one 560 * greater than the number of existing repetitions. 561 */ 562 public ADR_A19_PROCEDURE getPROCEDURE(int rep) { 563 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", rep, ADR_A19_PROCEDURE.class); 564 return retVal; 565 } 566 567 /** 568 * Returns the number of existing repetitions of PROCEDURE 569 */ 570 public int getPROCEDUREReps() { 571 return getReps("PROCEDURE"); 572 } 573 574 /** 575 * <p> 576 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 577 * <p> 578 * <p> 579 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 580 * if none are already present, so an empty list may be returned. 581 * </p> 582 */ 583 public java.util.List<ADR_A19_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 584 return getAllAsList("PROCEDURE", ADR_A19_PROCEDURE.class); 585 } 586 587 /** 588 * Inserts a specific repetition of PROCEDURE (a Group object) 589 * @see AbstractGroup#insertRepetition(Structure, int) 590 */ 591 public void insertPROCEDURE(ADR_A19_PROCEDURE structure, int rep) throws HL7Exception { 592 super.insertRepetition("PROCEDURE", structure, rep); 593 } 594 595 596 /** 597 * Inserts a specific repetition of PROCEDURE (a Group object) 598 * @see AbstractGroup#insertRepetition(Structure, int) 599 */ 600 public ADR_A19_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 601 return (ADR_A19_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 602 } 603 604 605 /** 606 * Removes a specific repetition of PROCEDURE (a Group object) 607 * @see AbstractGroup#removeRepetition(String, int) 608 */ 609 public ADR_A19_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 610 return (ADR_A19_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 611 } 612 613 614 615 /** 616 * Returns 617 * the first repetition of 618 * GT1 (Guarantor) - creates it if necessary 619 */ 620 public GT1 getGT1() { 621 GT1 retVal = getTyped("GT1", GT1.class); 622 return retVal; 623 } 624 625 626 /** 627 * Returns a specific repetition of 628 * GT1 (Guarantor) - creates it if necessary 629 * 630 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 631 * @throws HL7Exception if the repetition requested is more than one 632 * greater than the number of existing repetitions. 633 */ 634 public GT1 getGT1(int rep) { 635 GT1 retVal = getTyped("GT1", rep, GT1.class); 636 return retVal; 637 } 638 639 /** 640 * Returns the number of existing repetitions of GT1 641 */ 642 public int getGT1Reps() { 643 return getReps("GT1"); 644 } 645 646 /** 647 * <p> 648 * Returns a non-modifiable List containing all current existing repetitions of GT1. 649 * <p> 650 * <p> 651 * Note that unlike {@link #getGT1()}, this method will not create any reps 652 * if none are already present, so an empty list may be returned. 653 * </p> 654 */ 655 public java.util.List<GT1> getGT1All() throws HL7Exception { 656 return getAllAsList("GT1", GT1.class); 657 } 658 659 /** 660 * Inserts a specific repetition of GT1 (Guarantor) 661 * @see AbstractGroup#insertRepetition(Structure, int) 662 */ 663 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 664 super.insertRepetition("GT1", structure, rep); 665 } 666 667 668 /** 669 * Inserts a specific repetition of GT1 (Guarantor) 670 * @see AbstractGroup#insertRepetition(Structure, int) 671 */ 672 public GT1 insertGT1(int rep) throws HL7Exception { 673 return (GT1)super.insertRepetition("GT1", rep); 674 } 675 676 677 /** 678 * Removes a specific repetition of GT1 (Guarantor) 679 * @see AbstractGroup#removeRepetition(String, int) 680 */ 681 public GT1 removeGT1(int rep) throws HL7Exception { 682 return (GT1)super.removeRepetition("GT1", rep); 683 } 684 685 686 687 /** 688 * Returns 689 * the first repetition of 690 * INSURANCE (a Group object) - creates it if necessary 691 */ 692 public ADR_A19_INSURANCE getINSURANCE() { 693 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", ADR_A19_INSURANCE.class); 694 return retVal; 695 } 696 697 698 /** 699 * Returns a specific repetition of 700 * INSURANCE (a Group object) - creates it if necessary 701 * 702 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 703 * @throws HL7Exception if the repetition requested is more than one 704 * greater than the number of existing repetitions. 705 */ 706 public ADR_A19_INSURANCE getINSURANCE(int rep) { 707 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", rep, ADR_A19_INSURANCE.class); 708 return retVal; 709 } 710 711 /** 712 * Returns the number of existing repetitions of INSURANCE 713 */ 714 public int getINSURANCEReps() { 715 return getReps("INSURANCE"); 716 } 717 718 /** 719 * <p> 720 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 721 * <p> 722 * <p> 723 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 724 * if none are already present, so an empty list may be returned. 725 * </p> 726 */ 727 public java.util.List<ADR_A19_INSURANCE> getINSURANCEAll() throws HL7Exception { 728 return getAllAsList("INSURANCE", ADR_A19_INSURANCE.class); 729 } 730 731 /** 732 * Inserts a specific repetition of INSURANCE (a Group object) 733 * @see AbstractGroup#insertRepetition(Structure, int) 734 */ 735 public void insertINSURANCE(ADR_A19_INSURANCE structure, int rep) throws HL7Exception { 736 super.insertRepetition("INSURANCE", structure, rep); 737 } 738 739 740 /** 741 * Inserts a specific repetition of INSURANCE (a Group object) 742 * @see AbstractGroup#insertRepetition(Structure, int) 743 */ 744 public ADR_A19_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 745 return (ADR_A19_INSURANCE)super.insertRepetition("INSURANCE", rep); 746 } 747 748 749 /** 750 * Removes a specific repetition of INSURANCE (a Group object) 751 * @see AbstractGroup#removeRepetition(String, int) 752 */ 753 public ADR_A19_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 754 return (ADR_A19_INSURANCE)super.removeRepetition("INSURANCE", rep); 755 } 756 757 758 759 /** 760 * Returns 761 * ACC (Accident) - creates it if necessary 762 */ 763 public ACC getACC() { 764 ACC retVal = getTyped("ACC", ACC.class); 765 return retVal; 766 } 767 768 769 770 771 /** 772 * Returns 773 * UB1 (UB82 data) - creates it if necessary 774 */ 775 public UB1 getUB1() { 776 UB1 retVal = getTyped("UB1", UB1.class); 777 return retVal; 778 } 779 780 781 782 783 /** 784 * Returns 785 * UB2 (UB92 data) - creates it if necessary 786 */ 787 public UB2 getUB2() { 788 UB2 retVal = getTyped("UB2", UB2.class); 789 return retVal; 790 } 791 792 793 794 795} 796