1 /* 2 * This class is an auto-generated source file for a HAPI 3 * HL7 v2.x standard structure class. 4 * 5 * For more information, visit: http://hl7api.sourceforge.net/ 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 1.1 8 * (the "License"); you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 12 * specific language governing rights and limitations under the License. 13 * 14 * The Original Code is "[file_name]". Description: 15 * "[one_line_description]" 16 * 17 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 18 * 2012. All Rights Reserved. 19 * 20 * Contributor(s): ______________________________________. 21 * 22 * Alternatively, the contents of this file may be used under the terms of the 23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 24 * applicable instead of those above. If you wish to allow use of your version of this 25 * file only under the terms of the GPL and not to allow others to use your version 26 * of this file under the MPL, indicate your decision by deleting the provisions above 27 * and replace them with the notice and other provisions required by the GPL License. 28 * If you do not delete the provisions above, a recipient may use your version of 29 * this file under either the MPL or the GPL. 30 * 31 */ 32 33 34 package ca.uhn.hl7v2.model.v28.message; 35 36 import ca.uhn.hl7v2.model.v28.group.*; 37 import ca.uhn.hl7v2.model.v28.segment.*; 38 39 import ca.uhn.hl7v2.HL7Exception; 40 import ca.uhn.hl7v2.parser.ModelClassFactory; 41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 42 import ca.uhn.hl7v2.model.*; 43 44 45 /** 46 * <p>Represents a ADT_A17 message structure (see chapter 3.3.17). This structure contains the 47 * following elements: </p> 48 * <ul> 49 * <li>1: MSH (Message Header) <b> </b> </li> 50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li> 51 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li> 52 * <li>4: EVN (Event Type) <b> </b> </li> 53 * <li>5: PID (Patient Identification) <b> </b> </li> 54 * <li>6: PD1 (Patient Additional Demographic) <b>optional </b> </li> 55 * <li>7: PV1 (Patient Visit) <b> </b> </li> 56 * <li>8: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 57 * <li>9: DB1 (Disability) <b>optional repeating</b> </li> 58 * <li>10: OBX (Observation/Result) <b>optional repeating</b> </li> 59 * <li>11: PID (Patient Identification) <b> </b> </li> 60 * <li>12: PD1 (Patient Additional Demographic) <b>optional </b> </li> 61 * <li>13: PV1 (Patient Visit) <b> </b> </li> 62 * <li>14: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 63 * <li>15: DB1 (Disability) <b>optional repeating</b> </li> 64 * <li>16: OBX (Observation/Result) <b>optional repeating</b> </li> 65 * </ul> 66 */ 67 //@SuppressWarnings("unused") 68 public class ADT_A17 extends AbstractMessage { 69 70 /** 71 * Creates a new ADT_A17 message with DefaultModelClassFactory. 72 */ 73 public ADT_A17() { 74 this(new DefaultModelClassFactory()); 75 } 76 77 /** 78 * Creates a new ADT_A17 message with custom ModelClassFactory. 79 */ 80 public ADT_A17(ModelClassFactory factory) { 81 super(factory); 82 init(factory); 83 } 84 85 private void init(ModelClassFactory factory) { 86 try { 87 this.add(MSH.class, true, false); 88 this.add(SFT.class, false, true); 89 this.add(UAC.class, false, false); 90 this.add(EVN.class, true, false); 91 this.add(PID.class, true, false); 92 this.add(PD1.class, false, false); 93 this.add(PV1.class, true, false); 94 this.add(PV2.class, false, false); 95 this.add(DB1.class, false, true); 96 this.add(OBX.class, false, true); 97 this.add(PID.class, true, false); 98 this.add(PD1.class, false, false); 99 this.add(PV1.class, true, false); 100 this.add(PV2.class, false, false); 101 this.add(DB1.class, false, true); 102 this.add(OBX.class, false, true); 103 } catch(HL7Exception e) { 104 log.error("Unexpected error creating ADT_A17 - this is probably a bug in the source code generator.", e); 105 } 106 } 107 108 109 /** 110 * Returns "2.8" 111 */ 112 public String getVersion() { 113 return "2.8"; 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 * the first repetition of 139 * SFT (Software Segment) - creates it if necessary 140 * </p> 141 * 142 * 143 */ 144 public SFT getSFT() { 145 return getTyped("SFT", SFT.class); 146 } 147 148 149 /** 150 * <p> 151 * Returns a specific repetition of 152 * SFT (Software Segment) - creates it if necessary 153 * </p> 154 * 155 * 156 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 157 * @throws HL7Exception if the repetition requested is more than one 158 * greater than the number of existing repetitions. 159 */ 160 public SFT getSFT(int rep) { 161 return getTyped("SFT", rep, SFT.class); 162 } 163 164 /** 165 * <p> 166 * Returns the number of existing repetitions of SFT 167 * </p> 168 * 169 */ 170 public int getSFTReps() { 171 return getReps("SFT"); 172 } 173 174 /** 175 * <p> 176 * Returns a non-modifiable List containing all current existing repetitions of SFT. 177 * <p> 178 * <p> 179 * Note that unlike {@link #getSFT()}, this method will not create any reps 180 * if none are already present, so an empty list may be returned. 181 * </p> 182 * 183 */ 184 public java.util.List<SFT> getSFTAll() throws HL7Exception { 185 return getAllAsList("SFT", SFT.class); 186 } 187 188 /** 189 * <p> 190 * Inserts a specific repetition of SFT (Software Segment) 191 * </p> 192 * 193 * 194 * @see AbstractGroup#insertRepetition(Structure, int) 195 */ 196 public void insertSFT(SFT structure, int rep) throws HL7Exception { 197 super.insertRepetition( "SFT", structure, rep); 198 } 199 200 201 /** 202 * <p> 203 * Inserts a specific repetition of SFT (Software Segment) 204 * </p> 205 * 206 * 207 * @see AbstractGroup#insertRepetition(Structure, int) 208 */ 209 public SFT insertSFT(int rep) throws HL7Exception { 210 return (SFT)super.insertRepetition("SFT", rep); 211 } 212 213 214 /** 215 * <p> 216 * Removes a specific repetition of SFT (Software Segment) 217 * </p> 218 * 219 * 220 * @see AbstractGroup#removeRepetition(String, int) 221 */ 222 public SFT removeSFT(int rep) throws HL7Exception { 223 return (SFT)super.removeRepetition("SFT", rep); 224 } 225 226 227 228 229 /** 230 * <p> 231 * Returns 232 * UAC (User Authentication Credential Segment) - creates it if necessary 233 * </p> 234 * 235 * 236 */ 237 public UAC getUAC() { 238 return getTyped("UAC", UAC.class); 239 } 240 241 242 243 244 245 /** 246 * <p> 247 * Returns 248 * EVN (Event Type) - creates it if necessary 249 * </p> 250 * 251 * 252 */ 253 public EVN getEVN() { 254 return getTyped("EVN", EVN.class); 255 } 256 257 258 259 260 261 /** 262 * <p> 263 * Returns 264 * PID (Patient Identification) - creates it if necessary 265 * </p> 266 * 267 * 268 */ 269 public PID getPID() { 270 return getTyped("PID", PID.class); 271 } 272 273 274 275 276 277 /** 278 * <p> 279 * Returns 280 * PD1 (Patient Additional Demographic) - creates it if necessary 281 * </p> 282 * 283 * 284 */ 285 public PD1 getPD1() { 286 return getTyped("PD1", PD1.class); 287 } 288 289 290 291 292 293 /** 294 * <p> 295 * Returns 296 * PV1 (Patient Visit) - creates it if necessary 297 * </p> 298 * 299 * 300 */ 301 public PV1 getPV1() { 302 return getTyped("PV1", PV1.class); 303 } 304 305 306 307 308 309 /** 310 * <p> 311 * Returns 312 * PV2 (Patient Visit - Additional Information) - creates it if necessary 313 * </p> 314 * 315 * 316 */ 317 public PV2 getPV2() { 318 return getTyped("PV2", PV2.class); 319 } 320 321 322 323 324 325 /** 326 * <p> 327 * Returns 328 * the first repetition of 329 * DB1 (Disability) - creates it if necessary 330 * </p> 331 * 332 * 333 */ 334 public DB1 getDB1() { 335 return getTyped("DB1", DB1.class); 336 } 337 338 339 /** 340 * <p> 341 * Returns a specific repetition of 342 * DB1 (Disability) - creates it if necessary 343 * </p> 344 * 345 * 346 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 347 * @throws HL7Exception if the repetition requested is more than one 348 * greater than the number of existing repetitions. 349 */ 350 public DB1 getDB1(int rep) { 351 return getTyped("DB1", rep, DB1.class); 352 } 353 354 /** 355 * <p> 356 * Returns the number of existing repetitions of DB1 357 * </p> 358 * 359 */ 360 public int getDB1Reps() { 361 return getReps("DB1"); 362 } 363 364 /** 365 * <p> 366 * Returns a non-modifiable List containing all current existing repetitions of DB1. 367 * <p> 368 * <p> 369 * Note that unlike {@link #getDB1()}, this method will not create any reps 370 * if none are already present, so an empty list may be returned. 371 * </p> 372 * 373 */ 374 public java.util.List<DB1> getDB1All() throws HL7Exception { 375 return getAllAsList("DB1", DB1.class); 376 } 377 378 /** 379 * <p> 380 * Inserts a specific repetition of DB1 (Disability) 381 * </p> 382 * 383 * 384 * @see AbstractGroup#insertRepetition(Structure, int) 385 */ 386 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 387 super.insertRepetition( "DB1", structure, rep); 388 } 389 390 391 /** 392 * <p> 393 * Inserts a specific repetition of DB1 (Disability) 394 * </p> 395 * 396 * 397 * @see AbstractGroup#insertRepetition(Structure, int) 398 */ 399 public DB1 insertDB1(int rep) throws HL7Exception { 400 return (DB1)super.insertRepetition("DB1", rep); 401 } 402 403 404 /** 405 * <p> 406 * Removes a specific repetition of DB1 (Disability) 407 * </p> 408 * 409 * 410 * @see AbstractGroup#removeRepetition(String, int) 411 */ 412 public DB1 removeDB1(int rep) throws HL7Exception { 413 return (DB1)super.removeRepetition("DB1", rep); 414 } 415 416 417 418 419 /** 420 * <p> 421 * Returns 422 * the first repetition of 423 * OBX (Observation/Result) - creates it if necessary 424 * </p> 425 * 426 * 427 */ 428 public OBX getOBX() { 429 return getTyped("OBX", OBX.class); 430 } 431 432 433 /** 434 * <p> 435 * Returns a specific repetition of 436 * OBX (Observation/Result) - creates it if necessary 437 * </p> 438 * 439 * 440 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 441 * @throws HL7Exception if the repetition requested is more than one 442 * greater than the number of existing repetitions. 443 */ 444 public OBX getOBX(int rep) { 445 return getTyped("OBX", rep, OBX.class); 446 } 447 448 /** 449 * <p> 450 * Returns the number of existing repetitions of OBX 451 * </p> 452 * 453 */ 454 public int getOBXReps() { 455 return getReps("OBX"); 456 } 457 458 /** 459 * <p> 460 * Returns a non-modifiable List containing all current existing repetitions of OBX. 461 * <p> 462 * <p> 463 * Note that unlike {@link #getOBX()}, this method will not create any reps 464 * if none are already present, so an empty list may be returned. 465 * </p> 466 * 467 */ 468 public java.util.List<OBX> getOBXAll() throws HL7Exception { 469 return getAllAsList("OBX", OBX.class); 470 } 471 472 /** 473 * <p> 474 * Inserts a specific repetition of OBX (Observation/Result) 475 * </p> 476 * 477 * 478 * @see AbstractGroup#insertRepetition(Structure, int) 479 */ 480 public void insertOBX(OBX structure, int rep) throws HL7Exception { 481 super.insertRepetition( "OBX", structure, rep); 482 } 483 484 485 /** 486 * <p> 487 * Inserts a specific repetition of OBX (Observation/Result) 488 * </p> 489 * 490 * 491 * @see AbstractGroup#insertRepetition(Structure, int) 492 */ 493 public OBX insertOBX(int rep) throws HL7Exception { 494 return (OBX)super.insertRepetition("OBX", rep); 495 } 496 497 498 /** 499 * <p> 500 * Removes a specific repetition of OBX (Observation/Result) 501 * </p> 502 * 503 * 504 * @see AbstractGroup#removeRepetition(String, int) 505 */ 506 public OBX removeOBX(int rep) throws HL7Exception { 507 return (OBX)super.removeRepetition("OBX", rep); 508 } 509 510 511 512 513 /** 514 * <p> 515 * Returns 516 * PID2 (Patient Identification) - creates it if necessary 517 * </p> 518 * 519 * 520 */ 521 public PID getPID2() { 522 return getTyped("PID2", PID.class); 523 } 524 525 526 527 528 529 /** 530 * <p> 531 * Returns 532 * PD12 (Patient Additional Demographic) - creates it if necessary 533 * </p> 534 * 535 * 536 */ 537 public PD1 getPD12() { 538 return getTyped("PD12", PD1.class); 539 } 540 541 542 543 544 545 /** 546 * <p> 547 * Returns 548 * PV12 (Patient Visit) - creates it if necessary 549 * </p> 550 * 551 * 552 */ 553 public PV1 getPV12() { 554 return getTyped("PV12", PV1.class); 555 } 556 557 558 559 560 561 /** 562 * <p> 563 * Returns 564 * PV22 (Patient Visit - Additional Information) - creates it if necessary 565 * </p> 566 * 567 * 568 */ 569 public PV2 getPV22() { 570 return getTyped("PV22", PV2.class); 571 } 572 573 574 575 576 577 /** 578 * <p> 579 * Returns 580 * the first repetition of 581 * DB12 (Disability) - creates it if necessary 582 * </p> 583 * 584 * 585 */ 586 public DB1 getDB12() { 587 return getTyped("DB12", DB1.class); 588 } 589 590 591 /** 592 * <p> 593 * Returns a specific repetition of 594 * DB12 (Disability) - creates it if necessary 595 * </p> 596 * 597 * 598 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 599 * @throws HL7Exception if the repetition requested is more than one 600 * greater than the number of existing repetitions. 601 */ 602 public DB1 getDB12(int rep) { 603 return getTyped("DB12", rep, DB1.class); 604 } 605 606 /** 607 * <p> 608 * Returns the number of existing repetitions of DB12 609 * </p> 610 * 611 */ 612 public int getDB12Reps() { 613 return getReps("DB12"); 614 } 615 616 /** 617 * <p> 618 * Returns a non-modifiable List containing all current existing repetitions of DB12. 619 * <p> 620 * <p> 621 * Note that unlike {@link #getDB12()}, this method will not create any reps 622 * if none are already present, so an empty list may be returned. 623 * </p> 624 * 625 */ 626 public java.util.List<DB1> getDB12All() throws HL7Exception { 627 return getAllAsList("DB12", DB1.class); 628 } 629 630 /** 631 * <p> 632 * Inserts a specific repetition of DB12 (Disability) 633 * </p> 634 * 635 * 636 * @see AbstractGroup#insertRepetition(Structure, int) 637 */ 638 public void insertDB12(DB1 structure, int rep) throws HL7Exception { 639 super.insertRepetition( "DB12", structure, rep); 640 } 641 642 643 /** 644 * <p> 645 * Inserts a specific repetition of DB12 (Disability) 646 * </p> 647 * 648 * 649 * @see AbstractGroup#insertRepetition(Structure, int) 650 */ 651 public DB1 insertDB12(int rep) throws HL7Exception { 652 return (DB1)super.insertRepetition("DB12", rep); 653 } 654 655 656 /** 657 * <p> 658 * Removes a specific repetition of DB12 (Disability) 659 * </p> 660 * 661 * 662 * @see AbstractGroup#removeRepetition(String, int) 663 */ 664 public DB1 removeDB12(int rep) throws HL7Exception { 665 return (DB1)super.removeRepetition("DB12", rep); 666 } 667 668 669 670 671 /** 672 * <p> 673 * Returns 674 * the first repetition of 675 * OBX2 (Observation/Result) - creates it if necessary 676 * </p> 677 * 678 * 679 */ 680 public OBX getOBX2() { 681 return getTyped("OBX2", OBX.class); 682 } 683 684 685 /** 686 * <p> 687 * Returns a specific repetition of 688 * OBX2 (Observation/Result) - creates it if necessary 689 * </p> 690 * 691 * 692 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 693 * @throws HL7Exception if the repetition requested is more than one 694 * greater than the number of existing repetitions. 695 */ 696 public OBX getOBX2(int rep) { 697 return getTyped("OBX2", rep, OBX.class); 698 } 699 700 /** 701 * <p> 702 * Returns the number of existing repetitions of OBX2 703 * </p> 704 * 705 */ 706 public int getOBX2Reps() { 707 return getReps("OBX2"); 708 } 709 710 /** 711 * <p> 712 * Returns a non-modifiable List containing all current existing repetitions of OBX2. 713 * <p> 714 * <p> 715 * Note that unlike {@link #getOBX2()}, this method will not create any reps 716 * if none are already present, so an empty list may be returned. 717 * </p> 718 * 719 */ 720 public java.util.List<OBX> getOBX2All() throws HL7Exception { 721 return getAllAsList("OBX2", OBX.class); 722 } 723 724 /** 725 * <p> 726 * Inserts a specific repetition of OBX2 (Observation/Result) 727 * </p> 728 * 729 * 730 * @see AbstractGroup#insertRepetition(Structure, int) 731 */ 732 public void insertOBX2(OBX structure, int rep) throws HL7Exception { 733 super.insertRepetition( "OBX2", structure, rep); 734 } 735 736 737 /** 738 * <p> 739 * Inserts a specific repetition of OBX2 (Observation/Result) 740 * </p> 741 * 742 * 743 * @see AbstractGroup#insertRepetition(Structure, int) 744 */ 745 public OBX insertOBX2(int rep) throws HL7Exception { 746 return (OBX)super.insertRepetition("OBX2", rep); 747 } 748 749 750 /** 751 * <p> 752 * Removes a specific repetition of OBX2 (Observation/Result) 753 * </p> 754 * 755 * 756 * @see AbstractGroup#removeRepetition(String, int) 757 */ 758 public OBX removeOBX2(int rep) throws HL7Exception { 759 return (OBX)super.removeRepetition("OBX2", rep); 760 } 761 762 763 764 } 765