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.v25.segment; 035 036// import ca.uhn.hl7v2.model.v25.group.*; 037import ca.uhn.hl7v2.model.v25.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 PR1 message segment (Procedures). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>PR1-1: Set ID - PR1 (SI) <b> </b> 053 * <li>PR1-2: Procedure Coding Method (IS) <b>optional </b> 054 * <li>PR1-3: Procedure Code (CE) <b> </b> 055 * <li>PR1-4: Procedure Description (ST) <b>optional </b> 056 * <li>PR1-5: Procedure Date/Time (TS) <b> </b> 057 * <li>PR1-6: Procedure Functional Type (IS) <b>optional </b> 058 * <li>PR1-7: Procedure Minutes (NM) <b>optional </b> 059 * <li>PR1-8: Anesthesiologist (XCN) <b>optional repeating</b> 060 * <li>PR1-9: Anesthesia Code (IS) <b>optional </b> 061 * <li>PR1-10: Anesthesia Minutes (NM) <b>optional </b> 062 * <li>PR1-11: Surgeon (XCN) <b>optional repeating</b> 063 * <li>PR1-12: Procedure Practitioner (XCN) <b>optional repeating</b> 064 * <li>PR1-13: Consent Code (CE) <b>optional </b> 065 * <li>PR1-14: Procedure Priority (ID) <b>optional </b> 066 * <li>PR1-15: Associated Diagnosis Code (CE) <b>optional </b> 067 * <li>PR1-16: Procedure Code Modifier (CE) <b>optional repeating</b> 068 * <li>PR1-17: Procedure DRG Type (IS) <b>optional </b> 069 * <li>PR1-18: Tissue Type Code (CE) <b>optional repeating</b> 070 * <li>PR1-19: Procedure Identifier (EI) <b>optional </b> 071 * <li>PR1-20: Procedure Action Code (ID) <b>optional </b> 072 * </ul> 073 */ 074@SuppressWarnings("unused") 075public class PR1 extends AbstractSegment { 076 077 /** 078 * Creates a new PR1 segment 079 */ 080 public PR1(Group parent, ModelClassFactory factory) { 081 super(parent, factory); 082 init(factory); 083 } 084 085 private void init(ModelClassFactory factory) { 086 try { 087 this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - PR1"); 088 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(89) }, "Procedure Coding Method"); 089 this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Procedure Code"); 090 this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Procedure Description"); 091 this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Procedure Date/Time"); 092 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(230) }, "Procedure Functional Type"); 093 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Procedure Minutes"); 094 this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Anesthesiologist"); 095 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(19) }, "Anesthesia Code"); 096 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Anesthesia Minutes"); 097 this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Surgeon"); 098 this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Practitioner"); 099 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Consent Code"); 100 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(418) }, "Procedure Priority"); 101 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Associated Diagnosis Code"); 102 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Code Modifier"); 103 this.add(IS.class, false, 1, 20, new Object[]{ getMessage(), new Integer(416) }, "Procedure DRG Type"); 104 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Tissue Type Code"); 105 this.add(EI.class, false, 1, 427, new Object[]{ getMessage() }, "Procedure Identifier"); 106 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(206) }, "Procedure Action Code"); 107 } catch(HL7Exception e) { 108 log.error("Unexpected error creating PR1 - this is probably a bug in the source code generator.", e); 109 } 110 } 111 112 113 114 /** 115 * Returns 116 * PR1-1: "Set ID - PR1" - creates it if necessary 117 */ 118 public SI getSetIDPR1() { 119 SI retVal = this.getTypedField(1, 0); 120 return retVal; 121 } 122 123 /** 124 * Returns 125 * PR1-1: "Set ID - PR1" - creates it if necessary 126 */ 127 public SI getPr11_SetIDPR1() { 128 SI retVal = this.getTypedField(1, 0); 129 return retVal; 130 } 131 132 133 134 /** 135 * Returns 136 * PR1-2: "Procedure Coding Method" - creates it if necessary 137 */ 138 public IS getProcedureCodingMethod() { 139 IS retVal = this.getTypedField(2, 0); 140 return retVal; 141 } 142 143 /** 144 * Returns 145 * PR1-2: "Procedure Coding Method" - creates it if necessary 146 */ 147 public IS getPr12_ProcedureCodingMethod() { 148 IS retVal = this.getTypedField(2, 0); 149 return retVal; 150 } 151 152 153 154 /** 155 * Returns 156 * PR1-3: "Procedure Code" - creates it if necessary 157 */ 158 public CE getProcedureCode() { 159 CE retVal = this.getTypedField(3, 0); 160 return retVal; 161 } 162 163 /** 164 * Returns 165 * PR1-3: "Procedure Code" - creates it if necessary 166 */ 167 public CE getPr13_ProcedureCode() { 168 CE retVal = this.getTypedField(3, 0); 169 return retVal; 170 } 171 172 173 174 /** 175 * Returns 176 * PR1-4: "Procedure Description" - creates it if necessary 177 */ 178 public ST getProcedureDescription() { 179 ST retVal = this.getTypedField(4, 0); 180 return retVal; 181 } 182 183 /** 184 * Returns 185 * PR1-4: "Procedure Description" - creates it if necessary 186 */ 187 public ST getPr14_ProcedureDescription() { 188 ST retVal = this.getTypedField(4, 0); 189 return retVal; 190 } 191 192 193 194 /** 195 * Returns 196 * PR1-5: "Procedure Date/Time" - creates it if necessary 197 */ 198 public TS getProcedureDateTime() { 199 TS retVal = this.getTypedField(5, 0); 200 return retVal; 201 } 202 203 /** 204 * Returns 205 * PR1-5: "Procedure Date/Time" - creates it if necessary 206 */ 207 public TS getPr15_ProcedureDateTime() { 208 TS retVal = this.getTypedField(5, 0); 209 return retVal; 210 } 211 212 213 214 /** 215 * Returns 216 * PR1-6: "Procedure Functional Type" - creates it if necessary 217 */ 218 public IS getProcedureFunctionalType() { 219 IS retVal = this.getTypedField(6, 0); 220 return retVal; 221 } 222 223 /** 224 * Returns 225 * PR1-6: "Procedure Functional Type" - creates it if necessary 226 */ 227 public IS getPr16_ProcedureFunctionalType() { 228 IS retVal = this.getTypedField(6, 0); 229 return retVal; 230 } 231 232 233 234 /** 235 * Returns 236 * PR1-7: "Procedure Minutes" - creates it if necessary 237 */ 238 public NM getProcedureMinutes() { 239 NM retVal = this.getTypedField(7, 0); 240 return retVal; 241 } 242 243 /** 244 * Returns 245 * PR1-7: "Procedure Minutes" - creates it if necessary 246 */ 247 public NM getPr17_ProcedureMinutes() { 248 NM retVal = this.getTypedField(7, 0); 249 return retVal; 250 } 251 252 253 /** 254 * Returns all repetitions of Anesthesiologist (PR1-8). 255 */ 256 public XCN[] getAnesthesiologist() { 257 XCN[] retVal = this.getTypedField(8, new XCN[0]); 258 return retVal; 259 } 260 261 262 /** 263 * Returns all repetitions of Anesthesiologist (PR1-8). 264 */ 265 public XCN[] getPr18_Anesthesiologist() { 266 XCN[] retVal = this.getTypedField(8, new XCN[0]); 267 return retVal; 268 } 269 270 271 /** 272 * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8). 273 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 274 * it will return zero. 275 */ 276 public int getAnesthesiologistReps() { 277 return this.getReps(8); 278 } 279 280 281 /** 282 * Returns a specific repetition of 283 * PR1-8: "Anesthesiologist" - creates it if necessary 284 * 285 * @param rep The repetition index (0-indexed) 286 */ 287 public XCN getAnesthesiologist(int rep) { 288 XCN retVal = this.getTypedField(8, rep); 289 return retVal; 290 } 291 292 /** 293 * Returns a specific repetition of 294 * PR1-8: "Anesthesiologist" - creates it if necessary 295 * 296 * @param rep The repetition index (0-indexed) 297 */ 298 public XCN getPr18_Anesthesiologist(int rep) { 299 XCN retVal = this.getTypedField(8, rep); 300 return retVal; 301 } 302 303 /** 304 * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8). 305 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 306 * it will return zero. 307 */ 308 public int getPr18_AnesthesiologistReps() { 309 return this.getReps(8); 310 } 311 312 313 /** 314 * Inserts a repetition of 315 * PR1-8: "Anesthesiologist" at a specific index 316 * 317 * @param rep The repetition index (0-indexed) 318 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 319 */ 320 public XCN insertAnesthesiologist(int rep) throws HL7Exception { 321 return (XCN) super.insertRepetition(8, rep); 322 } 323 324 325 /** 326 * Inserts a repetition of 327 * PR1-8: "Anesthesiologist" at a specific index 328 * 329 * @param rep The repetition index (0-indexed) 330 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 331 */ 332 public XCN insertPr18_Anesthesiologist(int rep) throws HL7Exception { 333 return (XCN) super.insertRepetition(8, rep); 334 } 335 336 337 /** 338 * Removes a repetition of 339 * PR1-8: "Anesthesiologist" at a specific index 340 * 341 * @param rep The repetition index (0-indexed) 342 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 343 */ 344 public XCN removeAnesthesiologist(int rep) throws HL7Exception { 345 return (XCN) super.removeRepetition(8, rep); 346 } 347 348 349 /** 350 * Removes a repetition of 351 * PR1-8: "Anesthesiologist" at a specific index 352 * 353 * @param rep The repetition index (0-indexed) 354 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 355 */ 356 public XCN removePr18_Anesthesiologist(int rep) throws HL7Exception { 357 return (XCN) super.removeRepetition(8, rep); 358 } 359 360 361 362 363 /** 364 * Returns 365 * PR1-9: "Anesthesia Code" - creates it if necessary 366 */ 367 public IS getAnesthesiaCode() { 368 IS retVal = this.getTypedField(9, 0); 369 return retVal; 370 } 371 372 /** 373 * Returns 374 * PR1-9: "Anesthesia Code" - creates it if necessary 375 */ 376 public IS getPr19_AnesthesiaCode() { 377 IS retVal = this.getTypedField(9, 0); 378 return retVal; 379 } 380 381 382 383 /** 384 * Returns 385 * PR1-10: "Anesthesia Minutes" - creates it if necessary 386 */ 387 public NM getAnesthesiaMinutes() { 388 NM retVal = this.getTypedField(10, 0); 389 return retVal; 390 } 391 392 /** 393 * Returns 394 * PR1-10: "Anesthesia Minutes" - creates it if necessary 395 */ 396 public NM getPr110_AnesthesiaMinutes() { 397 NM retVal = this.getTypedField(10, 0); 398 return retVal; 399 } 400 401 402 /** 403 * Returns all repetitions of Surgeon (PR1-11). 404 */ 405 public XCN[] getSurgeon() { 406 XCN[] retVal = this.getTypedField(11, new XCN[0]); 407 return retVal; 408 } 409 410 411 /** 412 * Returns all repetitions of Surgeon (PR1-11). 413 */ 414 public XCN[] getPr111_Surgeon() { 415 XCN[] retVal = this.getTypedField(11, new XCN[0]); 416 return retVal; 417 } 418 419 420 /** 421 * Returns a count of the current number of repetitions of Surgeon (PR1-11). 422 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 423 * it will return zero. 424 */ 425 public int getSurgeonReps() { 426 return this.getReps(11); 427 } 428 429 430 /** 431 * Returns a specific repetition of 432 * PR1-11: "Surgeon" - creates it if necessary 433 * 434 * @param rep The repetition index (0-indexed) 435 */ 436 public XCN getSurgeon(int rep) { 437 XCN retVal = this.getTypedField(11, rep); 438 return retVal; 439 } 440 441 /** 442 * Returns a specific repetition of 443 * PR1-11: "Surgeon" - creates it if necessary 444 * 445 * @param rep The repetition index (0-indexed) 446 */ 447 public XCN getPr111_Surgeon(int rep) { 448 XCN retVal = this.getTypedField(11, rep); 449 return retVal; 450 } 451 452 /** 453 * Returns a count of the current number of repetitions of Surgeon (PR1-11). 454 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 455 * it will return zero. 456 */ 457 public int getPr111_SurgeonReps() { 458 return this.getReps(11); 459 } 460 461 462 /** 463 * Inserts a repetition of 464 * PR1-11: "Surgeon" at a specific index 465 * 466 * @param rep The repetition index (0-indexed) 467 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 468 */ 469 public XCN insertSurgeon(int rep) throws HL7Exception { 470 return (XCN) super.insertRepetition(11, rep); 471 } 472 473 474 /** 475 * Inserts a repetition of 476 * PR1-11: "Surgeon" at a specific index 477 * 478 * @param rep The repetition index (0-indexed) 479 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 480 */ 481 public XCN insertPr111_Surgeon(int rep) throws HL7Exception { 482 return (XCN) super.insertRepetition(11, rep); 483 } 484 485 486 /** 487 * Removes a repetition of 488 * PR1-11: "Surgeon" at a specific index 489 * 490 * @param rep The repetition index (0-indexed) 491 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 492 */ 493 public XCN removeSurgeon(int rep) throws HL7Exception { 494 return (XCN) super.removeRepetition(11, rep); 495 } 496 497 498 /** 499 * Removes a repetition of 500 * PR1-11: "Surgeon" at a specific index 501 * 502 * @param rep The repetition index (0-indexed) 503 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 504 */ 505 public XCN removePr111_Surgeon(int rep) throws HL7Exception { 506 return (XCN) super.removeRepetition(11, rep); 507 } 508 509 510 511 /** 512 * Returns all repetitions of Procedure Practitioner (PR1-12). 513 */ 514 public XCN[] getProcedurePractitioner() { 515 XCN[] retVal = this.getTypedField(12, new XCN[0]); 516 return retVal; 517 } 518 519 520 /** 521 * Returns all repetitions of Procedure Practitioner (PR1-12). 522 */ 523 public XCN[] getPr112_ProcedurePractitioner() { 524 XCN[] retVal = this.getTypedField(12, new XCN[0]); 525 return retVal; 526 } 527 528 529 /** 530 * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12). 531 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 532 * it will return zero. 533 */ 534 public int getProcedurePractitionerReps() { 535 return this.getReps(12); 536 } 537 538 539 /** 540 * Returns a specific repetition of 541 * PR1-12: "Procedure Practitioner" - creates it if necessary 542 * 543 * @param rep The repetition index (0-indexed) 544 */ 545 public XCN getProcedurePractitioner(int rep) { 546 XCN retVal = this.getTypedField(12, rep); 547 return retVal; 548 } 549 550 /** 551 * Returns a specific repetition of 552 * PR1-12: "Procedure Practitioner" - creates it if necessary 553 * 554 * @param rep The repetition index (0-indexed) 555 */ 556 public XCN getPr112_ProcedurePractitioner(int rep) { 557 XCN retVal = this.getTypedField(12, rep); 558 return retVal; 559 } 560 561 /** 562 * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12). 563 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 564 * it will return zero. 565 */ 566 public int getPr112_ProcedurePractitionerReps() { 567 return this.getReps(12); 568 } 569 570 571 /** 572 * Inserts a repetition of 573 * PR1-12: "Procedure Practitioner" at a specific index 574 * 575 * @param rep The repetition index (0-indexed) 576 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 577 */ 578 public XCN insertProcedurePractitioner(int rep) throws HL7Exception { 579 return (XCN) super.insertRepetition(12, rep); 580 } 581 582 583 /** 584 * Inserts a repetition of 585 * PR1-12: "Procedure Practitioner" at a specific index 586 * 587 * @param rep The repetition index (0-indexed) 588 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 589 */ 590 public XCN insertPr112_ProcedurePractitioner(int rep) throws HL7Exception { 591 return (XCN) super.insertRepetition(12, rep); 592 } 593 594 595 /** 596 * Removes a repetition of 597 * PR1-12: "Procedure Practitioner" at a specific index 598 * 599 * @param rep The repetition index (0-indexed) 600 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 601 */ 602 public XCN removeProcedurePractitioner(int rep) throws HL7Exception { 603 return (XCN) super.removeRepetition(12, rep); 604 } 605 606 607 /** 608 * Removes a repetition of 609 * PR1-12: "Procedure Practitioner" at a specific index 610 * 611 * @param rep The repetition index (0-indexed) 612 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 613 */ 614 public XCN removePr112_ProcedurePractitioner(int rep) throws HL7Exception { 615 return (XCN) super.removeRepetition(12, rep); 616 } 617 618 619 620 621 /** 622 * Returns 623 * PR1-13: "Consent Code" - creates it if necessary 624 */ 625 public CE getConsentCode() { 626 CE retVal = this.getTypedField(13, 0); 627 return retVal; 628 } 629 630 /** 631 * Returns 632 * PR1-13: "Consent Code" - creates it if necessary 633 */ 634 public CE getPr113_ConsentCode() { 635 CE retVal = this.getTypedField(13, 0); 636 return retVal; 637 } 638 639 640 641 /** 642 * Returns 643 * PR1-14: "Procedure Priority" - creates it if necessary 644 */ 645 public ID getProcedurePriority() { 646 ID retVal = this.getTypedField(14, 0); 647 return retVal; 648 } 649 650 /** 651 * Returns 652 * PR1-14: "Procedure Priority" - creates it if necessary 653 */ 654 public ID getPr114_ProcedurePriority() { 655 ID retVal = this.getTypedField(14, 0); 656 return retVal; 657 } 658 659 660 661 /** 662 * Returns 663 * PR1-15: "Associated Diagnosis Code" - creates it if necessary 664 */ 665 public CE getAssociatedDiagnosisCode() { 666 CE retVal = this.getTypedField(15, 0); 667 return retVal; 668 } 669 670 /** 671 * Returns 672 * PR1-15: "Associated Diagnosis Code" - creates it if necessary 673 */ 674 public CE getPr115_AssociatedDiagnosisCode() { 675 CE retVal = this.getTypedField(15, 0); 676 return retVal; 677 } 678 679 680 /** 681 * Returns all repetitions of Procedure Code Modifier (PR1-16). 682 */ 683 public CE[] getProcedureCodeModifier() { 684 CE[] retVal = this.getTypedField(16, new CE[0]); 685 return retVal; 686 } 687 688 689 /** 690 * Returns all repetitions of Procedure Code Modifier (PR1-16). 691 */ 692 public CE[] getPr116_ProcedureCodeModifier() { 693 CE[] retVal = this.getTypedField(16, new CE[0]); 694 return retVal; 695 } 696 697 698 /** 699 * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16). 700 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 701 * it will return zero. 702 */ 703 public int getProcedureCodeModifierReps() { 704 return this.getReps(16); 705 } 706 707 708 /** 709 * Returns a specific repetition of 710 * PR1-16: "Procedure Code Modifier" - creates it if necessary 711 * 712 * @param rep The repetition index (0-indexed) 713 */ 714 public CE getProcedureCodeModifier(int rep) { 715 CE retVal = this.getTypedField(16, rep); 716 return retVal; 717 } 718 719 /** 720 * Returns a specific repetition of 721 * PR1-16: "Procedure Code Modifier" - creates it if necessary 722 * 723 * @param rep The repetition index (0-indexed) 724 */ 725 public CE getPr116_ProcedureCodeModifier(int rep) { 726 CE retVal = this.getTypedField(16, rep); 727 return retVal; 728 } 729 730 /** 731 * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16). 732 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 733 * it will return zero. 734 */ 735 public int getPr116_ProcedureCodeModifierReps() { 736 return this.getReps(16); 737 } 738 739 740 /** 741 * Inserts a repetition of 742 * PR1-16: "Procedure Code Modifier" at a specific index 743 * 744 * @param rep The repetition index (0-indexed) 745 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 746 */ 747 public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 748 return (CE) super.insertRepetition(16, rep); 749 } 750 751 752 /** 753 * Inserts a repetition of 754 * PR1-16: "Procedure Code Modifier" at a specific index 755 * 756 * @param rep The repetition index (0-indexed) 757 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 758 */ 759 public CE insertPr116_ProcedureCodeModifier(int rep) throws HL7Exception { 760 return (CE) super.insertRepetition(16, rep); 761 } 762 763 764 /** 765 * Removes a repetition of 766 * PR1-16: "Procedure Code Modifier" at a specific index 767 * 768 * @param rep The repetition index (0-indexed) 769 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 770 */ 771 public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 772 return (CE) super.removeRepetition(16, rep); 773 } 774 775 776 /** 777 * Removes a repetition of 778 * PR1-16: "Procedure Code Modifier" at a specific index 779 * 780 * @param rep The repetition index (0-indexed) 781 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 782 */ 783 public CE removePr116_ProcedureCodeModifier(int rep) throws HL7Exception { 784 return (CE) super.removeRepetition(16, rep); 785 } 786 787 788 789 790 /** 791 * Returns 792 * PR1-17: "Procedure DRG Type" - creates it if necessary 793 */ 794 public IS getProcedureDRGType() { 795 IS retVal = this.getTypedField(17, 0); 796 return retVal; 797 } 798 799 /** 800 * Returns 801 * PR1-17: "Procedure DRG Type" - creates it if necessary 802 */ 803 public IS getPr117_ProcedureDRGType() { 804 IS retVal = this.getTypedField(17, 0); 805 return retVal; 806 } 807 808 809 /** 810 * Returns all repetitions of Tissue Type Code (PR1-18). 811 */ 812 public CE[] getTissueTypeCode() { 813 CE[] retVal = this.getTypedField(18, new CE[0]); 814 return retVal; 815 } 816 817 818 /** 819 * Returns all repetitions of Tissue Type Code (PR1-18). 820 */ 821 public CE[] getPr118_TissueTypeCode() { 822 CE[] retVal = this.getTypedField(18, new CE[0]); 823 return retVal; 824 } 825 826 827 /** 828 * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18). 829 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 830 * it will return zero. 831 */ 832 public int getTissueTypeCodeReps() { 833 return this.getReps(18); 834 } 835 836 837 /** 838 * Returns a specific repetition of 839 * PR1-18: "Tissue Type Code" - creates it if necessary 840 * 841 * @param rep The repetition index (0-indexed) 842 */ 843 public CE getTissueTypeCode(int rep) { 844 CE retVal = this.getTypedField(18, rep); 845 return retVal; 846 } 847 848 /** 849 * Returns a specific repetition of 850 * PR1-18: "Tissue Type Code" - creates it if necessary 851 * 852 * @param rep The repetition index (0-indexed) 853 */ 854 public CE getPr118_TissueTypeCode(int rep) { 855 CE retVal = this.getTypedField(18, rep); 856 return retVal; 857 } 858 859 /** 860 * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18). 861 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 862 * it will return zero. 863 */ 864 public int getPr118_TissueTypeCodeReps() { 865 return this.getReps(18); 866 } 867 868 869 /** 870 * Inserts a repetition of 871 * PR1-18: "Tissue Type Code" at a specific index 872 * 873 * @param rep The repetition index (0-indexed) 874 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 875 */ 876 public CE insertTissueTypeCode(int rep) throws HL7Exception { 877 return (CE) super.insertRepetition(18, rep); 878 } 879 880 881 /** 882 * Inserts a repetition of 883 * PR1-18: "Tissue Type Code" at a specific index 884 * 885 * @param rep The repetition index (0-indexed) 886 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 887 */ 888 public CE insertPr118_TissueTypeCode(int rep) throws HL7Exception { 889 return (CE) super.insertRepetition(18, rep); 890 } 891 892 893 /** 894 * Removes a repetition of 895 * PR1-18: "Tissue Type Code" at a specific index 896 * 897 * @param rep The repetition index (0-indexed) 898 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 899 */ 900 public CE removeTissueTypeCode(int rep) throws HL7Exception { 901 return (CE) super.removeRepetition(18, rep); 902 } 903 904 905 /** 906 * Removes a repetition of 907 * PR1-18: "Tissue Type Code" at a specific index 908 * 909 * @param rep The repetition index (0-indexed) 910 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 911 */ 912 public CE removePr118_TissueTypeCode(int rep) throws HL7Exception { 913 return (CE) super.removeRepetition(18, rep); 914 } 915 916 917 918 919 /** 920 * Returns 921 * PR1-19: "Procedure Identifier" - creates it if necessary 922 */ 923 public EI getProcedureIdentifier() { 924 EI retVal = this.getTypedField(19, 0); 925 return retVal; 926 } 927 928 /** 929 * Returns 930 * PR1-19: "Procedure Identifier" - creates it if necessary 931 */ 932 public EI getPr119_ProcedureIdentifier() { 933 EI retVal = this.getTypedField(19, 0); 934 return retVal; 935 } 936 937 938 939 /** 940 * Returns 941 * PR1-20: "Procedure Action Code" - creates it if necessary 942 */ 943 public ID getProcedureActionCode() { 944 ID retVal = this.getTypedField(20, 0); 945 return retVal; 946 } 947 948 /** 949 * Returns 950 * PR1-20: "Procedure Action Code" - creates it if necessary 951 */ 952 public ID getPr120_ProcedureActionCode() { 953 ID retVal = this.getTypedField(20, 0); 954 return retVal; 955 } 956 957 958 959 960 961 /** {@inheritDoc} */ 962 protected Type createNewTypeWithoutReflection(int field) { 963 switch (field) { 964 case 0: return new SI(getMessage()); 965 case 1: return new IS(getMessage(), new Integer( 89 )); 966 case 2: return new CE(getMessage()); 967 case 3: return new ST(getMessage()); 968 case 4: return new TS(getMessage()); 969 case 5: return new IS(getMessage(), new Integer( 230 )); 970 case 6: return new NM(getMessage()); 971 case 7: return new XCN(getMessage()); 972 case 8: return new IS(getMessage(), new Integer( 19 )); 973 case 9: return new NM(getMessage()); 974 case 10: return new XCN(getMessage()); 975 case 11: return new XCN(getMessage()); 976 case 12: return new CE(getMessage()); 977 case 13: return new ID(getMessage(), new Integer( 418 )); 978 case 14: return new CE(getMessage()); 979 case 15: return new CE(getMessage()); 980 case 16: return new IS(getMessage(), new Integer( 416 )); 981 case 17: return new CE(getMessage()); 982 case 18: return new EI(getMessage()); 983 case 19: return new ID(getMessage(), new Integer( 206 )); 984 default: return null; 985 } 986 } 987 988 989} 990