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.v231.segment; 035 036// import ca.uhn.hl7v2.model.v231.group.*; 037import ca.uhn.hl7v2.model.v231.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 (PR1 - procedures segment). 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> </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 (NM) <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 * </ul> 069 */ 070@SuppressWarnings("unused") 071public class PR1 extends AbstractSegment { 072 073 /** 074 * Creates a new PR1 segment 075 */ 076 public PR1(Group parent, ModelClassFactory factory) { 077 super(parent, factory); 078 init(factory); 079 } 080 081 private void init(ModelClassFactory factory) { 082 try { 083 this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - PR1"); 084 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(89) }, "Procedure Coding Method"); 085 this.add(CE.class, true, 1, 80, new Object[]{ getMessage() }, "Procedure Code"); 086 this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Procedure Description"); 087 this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Procedure Date/Time"); 088 this.add(IS.class, true, 1, 2, new Object[]{ getMessage(), new Integer(230) }, "Procedure Functional Type"); 089 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Procedure Minutes"); 090 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Anesthesiologist"); 091 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(19) }, "Anesthesia Code"); 092 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Anesthesia Minutes"); 093 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Surgeon"); 094 this.add(XCN.class, false, 0, 230, new Object[]{ getMessage() }, "Procedure Practitioner"); 095 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Consent Code"); 096 this.add(NM.class, false, 1, 2, new Object[]{ getMessage() }, "Procedure Priority"); 097 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Associated Diagnosis Code"); 098 this.add(CE.class, false, 0, 80, new Object[]{ getMessage() }, "Procedure Code Modifier"); 099 } catch(HL7Exception e) { 100 log.error("Unexpected error creating PR1 - this is probably a bug in the source code generator.", e); 101 } 102 } 103 104 105 106 /** 107 * Returns 108 * PR1-1: "Set ID - PR1" - creates it if necessary 109 */ 110 public SI getSetIDPR1() { 111 SI retVal = this.getTypedField(1, 0); 112 return retVal; 113 } 114 115 /** 116 * Returns 117 * PR1-1: "Set ID - PR1" - creates it if necessary 118 */ 119 public SI getPr11_SetIDPR1() { 120 SI retVal = this.getTypedField(1, 0); 121 return retVal; 122 } 123 124 125 126 /** 127 * Returns 128 * PR1-2: "Procedure Coding Method" - creates it if necessary 129 */ 130 public IS getProcedureCodingMethod() { 131 IS retVal = this.getTypedField(2, 0); 132 return retVal; 133 } 134 135 /** 136 * Returns 137 * PR1-2: "Procedure Coding Method" - creates it if necessary 138 */ 139 public IS getPr12_ProcedureCodingMethod() { 140 IS retVal = this.getTypedField(2, 0); 141 return retVal; 142 } 143 144 145 146 /** 147 * Returns 148 * PR1-3: "Procedure Code" - creates it if necessary 149 */ 150 public CE getProcedureCode() { 151 CE retVal = this.getTypedField(3, 0); 152 return retVal; 153 } 154 155 /** 156 * Returns 157 * PR1-3: "Procedure Code" - creates it if necessary 158 */ 159 public CE getPr13_ProcedureCode() { 160 CE retVal = this.getTypedField(3, 0); 161 return retVal; 162 } 163 164 165 166 /** 167 * Returns 168 * PR1-4: "Procedure Description" - creates it if necessary 169 */ 170 public ST getProcedureDescription() { 171 ST retVal = this.getTypedField(4, 0); 172 return retVal; 173 } 174 175 /** 176 * Returns 177 * PR1-4: "Procedure Description" - creates it if necessary 178 */ 179 public ST getPr14_ProcedureDescription() { 180 ST retVal = this.getTypedField(4, 0); 181 return retVal; 182 } 183 184 185 186 /** 187 * Returns 188 * PR1-5: "Procedure Date/Time" - creates it if necessary 189 */ 190 public TS getProcedureDateTime() { 191 TS retVal = this.getTypedField(5, 0); 192 return retVal; 193 } 194 195 /** 196 * Returns 197 * PR1-5: "Procedure Date/Time" - creates it if necessary 198 */ 199 public TS getPr15_ProcedureDateTime() { 200 TS retVal = this.getTypedField(5, 0); 201 return retVal; 202 } 203 204 205 206 /** 207 * Returns 208 * PR1-6: "Procedure Functional Type" - creates it if necessary 209 */ 210 public IS getProcedureFunctionalType() { 211 IS retVal = this.getTypedField(6, 0); 212 return retVal; 213 } 214 215 /** 216 * Returns 217 * PR1-6: "Procedure Functional Type" - creates it if necessary 218 */ 219 public IS getPr16_ProcedureFunctionalType() { 220 IS retVal = this.getTypedField(6, 0); 221 return retVal; 222 } 223 224 225 226 /** 227 * Returns 228 * PR1-7: "Procedure Minutes" - creates it if necessary 229 */ 230 public NM getProcedureMinutes() { 231 NM retVal = this.getTypedField(7, 0); 232 return retVal; 233 } 234 235 /** 236 * Returns 237 * PR1-7: "Procedure Minutes" - creates it if necessary 238 */ 239 public NM getPr17_ProcedureMinutes() { 240 NM retVal = this.getTypedField(7, 0); 241 return retVal; 242 } 243 244 245 /** 246 * Returns all repetitions of Anesthesiologist (PR1-8). 247 */ 248 public XCN[] getAnesthesiologist() { 249 XCN[] retVal = this.getTypedField(8, new XCN[0]); 250 return retVal; 251 } 252 253 254 /** 255 * Returns all repetitions of Anesthesiologist (PR1-8). 256 */ 257 public XCN[] getPr18_Anesthesiologist() { 258 XCN[] retVal = this.getTypedField(8, new XCN[0]); 259 return retVal; 260 } 261 262 263 /** 264 * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8). 265 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 266 * it will return zero. 267 */ 268 public int getAnesthesiologistReps() { 269 return this.getReps(8); 270 } 271 272 273 /** 274 * Returns a specific repetition of 275 * PR1-8: "Anesthesiologist" - creates it if necessary 276 * 277 * @param rep The repetition index (0-indexed) 278 */ 279 public XCN getAnesthesiologist(int rep) { 280 XCN retVal = this.getTypedField(8, rep); 281 return retVal; 282 } 283 284 /** 285 * Returns a specific repetition of 286 * PR1-8: "Anesthesiologist" - creates it if necessary 287 * 288 * @param rep The repetition index (0-indexed) 289 */ 290 public XCN getPr18_Anesthesiologist(int rep) { 291 XCN retVal = this.getTypedField(8, rep); 292 return retVal; 293 } 294 295 /** 296 * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8). 297 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 298 * it will return zero. 299 */ 300 public int getPr18_AnesthesiologistReps() { 301 return this.getReps(8); 302 } 303 304 305 /** 306 * Inserts a repetition of 307 * PR1-8: "Anesthesiologist" at a specific index 308 * 309 * @param rep The repetition index (0-indexed) 310 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 311 */ 312 public XCN insertAnesthesiologist(int rep) throws HL7Exception { 313 return (XCN) super.insertRepetition(8, rep); 314 } 315 316 317 /** 318 * Inserts a repetition of 319 * PR1-8: "Anesthesiologist" at a specific index 320 * 321 * @param rep The repetition index (0-indexed) 322 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 323 */ 324 public XCN insertPr18_Anesthesiologist(int rep) throws HL7Exception { 325 return (XCN) super.insertRepetition(8, rep); 326 } 327 328 329 /** 330 * Removes a repetition of 331 * PR1-8: "Anesthesiologist" at a specific index 332 * 333 * @param rep The repetition index (0-indexed) 334 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 335 */ 336 public XCN removeAnesthesiologist(int rep) throws HL7Exception { 337 return (XCN) super.removeRepetition(8, rep); 338 } 339 340 341 /** 342 * Removes a repetition of 343 * PR1-8: "Anesthesiologist" at a specific index 344 * 345 * @param rep The repetition index (0-indexed) 346 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 347 */ 348 public XCN removePr18_Anesthesiologist(int rep) throws HL7Exception { 349 return (XCN) super.removeRepetition(8, rep); 350 } 351 352 353 354 355 /** 356 * Returns 357 * PR1-9: "Anesthesia Code" - creates it if necessary 358 */ 359 public IS getAnesthesiaCode() { 360 IS retVal = this.getTypedField(9, 0); 361 return retVal; 362 } 363 364 /** 365 * Returns 366 * PR1-9: "Anesthesia Code" - creates it if necessary 367 */ 368 public IS getPr19_AnesthesiaCode() { 369 IS retVal = this.getTypedField(9, 0); 370 return retVal; 371 } 372 373 374 375 /** 376 * Returns 377 * PR1-10: "Anesthesia Minutes" - creates it if necessary 378 */ 379 public NM getAnesthesiaMinutes() { 380 NM retVal = this.getTypedField(10, 0); 381 return retVal; 382 } 383 384 /** 385 * Returns 386 * PR1-10: "Anesthesia Minutes" - creates it if necessary 387 */ 388 public NM getPr110_AnesthesiaMinutes() { 389 NM retVal = this.getTypedField(10, 0); 390 return retVal; 391 } 392 393 394 /** 395 * Returns all repetitions of Surgeon (PR1-11). 396 */ 397 public XCN[] getSurgeon() { 398 XCN[] retVal = this.getTypedField(11, new XCN[0]); 399 return retVal; 400 } 401 402 403 /** 404 * Returns all repetitions of Surgeon (PR1-11). 405 */ 406 public XCN[] getPr111_Surgeon() { 407 XCN[] retVal = this.getTypedField(11, new XCN[0]); 408 return retVal; 409 } 410 411 412 /** 413 * Returns a count of the current number of repetitions of Surgeon (PR1-11). 414 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 415 * it will return zero. 416 */ 417 public int getSurgeonReps() { 418 return this.getReps(11); 419 } 420 421 422 /** 423 * Returns a specific repetition of 424 * PR1-11: "Surgeon" - creates it if necessary 425 * 426 * @param rep The repetition index (0-indexed) 427 */ 428 public XCN getSurgeon(int rep) { 429 XCN retVal = this.getTypedField(11, rep); 430 return retVal; 431 } 432 433 /** 434 * Returns a specific repetition of 435 * PR1-11: "Surgeon" - creates it if necessary 436 * 437 * @param rep The repetition index (0-indexed) 438 */ 439 public XCN getPr111_Surgeon(int rep) { 440 XCN retVal = this.getTypedField(11, rep); 441 return retVal; 442 } 443 444 /** 445 * Returns a count of the current number of repetitions of Surgeon (PR1-11). 446 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 447 * it will return zero. 448 */ 449 public int getPr111_SurgeonReps() { 450 return this.getReps(11); 451 } 452 453 454 /** 455 * Inserts a repetition of 456 * PR1-11: "Surgeon" at a specific index 457 * 458 * @param rep The repetition index (0-indexed) 459 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 460 */ 461 public XCN insertSurgeon(int rep) throws HL7Exception { 462 return (XCN) super.insertRepetition(11, rep); 463 } 464 465 466 /** 467 * Inserts a repetition of 468 * PR1-11: "Surgeon" at a specific index 469 * 470 * @param rep The repetition index (0-indexed) 471 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 472 */ 473 public XCN insertPr111_Surgeon(int rep) throws HL7Exception { 474 return (XCN) super.insertRepetition(11, rep); 475 } 476 477 478 /** 479 * Removes a repetition of 480 * PR1-11: "Surgeon" at a specific index 481 * 482 * @param rep The repetition index (0-indexed) 483 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 484 */ 485 public XCN removeSurgeon(int rep) throws HL7Exception { 486 return (XCN) super.removeRepetition(11, rep); 487 } 488 489 490 /** 491 * Removes a repetition of 492 * PR1-11: "Surgeon" at a specific index 493 * 494 * @param rep The repetition index (0-indexed) 495 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 496 */ 497 public XCN removePr111_Surgeon(int rep) throws HL7Exception { 498 return (XCN) super.removeRepetition(11, rep); 499 } 500 501 502 503 /** 504 * Returns all repetitions of Procedure Practitioner (PR1-12). 505 */ 506 public XCN[] getProcedurePractitioner() { 507 XCN[] retVal = this.getTypedField(12, new XCN[0]); 508 return retVal; 509 } 510 511 512 /** 513 * Returns all repetitions of Procedure Practitioner (PR1-12). 514 */ 515 public XCN[] getPr112_ProcedurePractitioner() { 516 XCN[] retVal = this.getTypedField(12, new XCN[0]); 517 return retVal; 518 } 519 520 521 /** 522 * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12). 523 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 524 * it will return zero. 525 */ 526 public int getProcedurePractitionerReps() { 527 return this.getReps(12); 528 } 529 530 531 /** 532 * Returns a specific repetition of 533 * PR1-12: "Procedure Practitioner" - creates it if necessary 534 * 535 * @param rep The repetition index (0-indexed) 536 */ 537 public XCN getProcedurePractitioner(int rep) { 538 XCN retVal = this.getTypedField(12, rep); 539 return retVal; 540 } 541 542 /** 543 * Returns a specific repetition of 544 * PR1-12: "Procedure Practitioner" - creates it if necessary 545 * 546 * @param rep The repetition index (0-indexed) 547 */ 548 public XCN getPr112_ProcedurePractitioner(int rep) { 549 XCN retVal = this.getTypedField(12, rep); 550 return retVal; 551 } 552 553 /** 554 * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12). 555 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 556 * it will return zero. 557 */ 558 public int getPr112_ProcedurePractitionerReps() { 559 return this.getReps(12); 560 } 561 562 563 /** 564 * Inserts a repetition of 565 * PR1-12: "Procedure Practitioner" at a specific index 566 * 567 * @param rep The repetition index (0-indexed) 568 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 569 */ 570 public XCN insertProcedurePractitioner(int rep) throws HL7Exception { 571 return (XCN) super.insertRepetition(12, rep); 572 } 573 574 575 /** 576 * Inserts a repetition of 577 * PR1-12: "Procedure Practitioner" at a specific index 578 * 579 * @param rep The repetition index (0-indexed) 580 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 581 */ 582 public XCN insertPr112_ProcedurePractitioner(int rep) throws HL7Exception { 583 return (XCN) super.insertRepetition(12, rep); 584 } 585 586 587 /** 588 * Removes a repetition of 589 * PR1-12: "Procedure Practitioner" at a specific index 590 * 591 * @param rep The repetition index (0-indexed) 592 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 593 */ 594 public XCN removeProcedurePractitioner(int rep) throws HL7Exception { 595 return (XCN) super.removeRepetition(12, rep); 596 } 597 598 599 /** 600 * Removes a repetition of 601 * PR1-12: "Procedure Practitioner" at a specific index 602 * 603 * @param rep The repetition index (0-indexed) 604 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 605 */ 606 public XCN removePr112_ProcedurePractitioner(int rep) throws HL7Exception { 607 return (XCN) super.removeRepetition(12, rep); 608 } 609 610 611 612 613 /** 614 * Returns 615 * PR1-13: "Consent Code" - creates it if necessary 616 */ 617 public CE getConsentCode() { 618 CE retVal = this.getTypedField(13, 0); 619 return retVal; 620 } 621 622 /** 623 * Returns 624 * PR1-13: "Consent Code" - creates it if necessary 625 */ 626 public CE getPr113_ConsentCode() { 627 CE retVal = this.getTypedField(13, 0); 628 return retVal; 629 } 630 631 632 633 /** 634 * Returns 635 * PR1-14: "Procedure Priority" - creates it if necessary 636 */ 637 public NM getProcedurePriority() { 638 NM retVal = this.getTypedField(14, 0); 639 return retVal; 640 } 641 642 /** 643 * Returns 644 * PR1-14: "Procedure Priority" - creates it if necessary 645 */ 646 public NM getPr114_ProcedurePriority() { 647 NM retVal = this.getTypedField(14, 0); 648 return retVal; 649 } 650 651 652 653 /** 654 * Returns 655 * PR1-15: "Associated Diagnosis Code" - creates it if necessary 656 */ 657 public CE getAssociatedDiagnosisCode() { 658 CE retVal = this.getTypedField(15, 0); 659 return retVal; 660 } 661 662 /** 663 * Returns 664 * PR1-15: "Associated Diagnosis Code" - creates it if necessary 665 */ 666 public CE getPr115_AssociatedDiagnosisCode() { 667 CE retVal = this.getTypedField(15, 0); 668 return retVal; 669 } 670 671 672 /** 673 * Returns all repetitions of Procedure Code Modifier (PR1-16). 674 */ 675 public CE[] getProcedureCodeModifier() { 676 CE[] retVal = this.getTypedField(16, new CE[0]); 677 return retVal; 678 } 679 680 681 /** 682 * Returns all repetitions of Procedure Code Modifier (PR1-16). 683 */ 684 public CE[] getPr116_ProcedureCodeModifier() { 685 CE[] retVal = this.getTypedField(16, new CE[0]); 686 return retVal; 687 } 688 689 690 /** 691 * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16). 692 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 693 * it will return zero. 694 */ 695 public int getProcedureCodeModifierReps() { 696 return this.getReps(16); 697 } 698 699 700 /** 701 * Returns a specific repetition of 702 * PR1-16: "Procedure Code Modifier" - creates it if necessary 703 * 704 * @param rep The repetition index (0-indexed) 705 */ 706 public CE getProcedureCodeModifier(int rep) { 707 CE retVal = this.getTypedField(16, rep); 708 return retVal; 709 } 710 711 /** 712 * Returns a specific repetition of 713 * PR1-16: "Procedure Code Modifier" - creates it if necessary 714 * 715 * @param rep The repetition index (0-indexed) 716 */ 717 public CE getPr116_ProcedureCodeModifier(int rep) { 718 CE retVal = this.getTypedField(16, rep); 719 return retVal; 720 } 721 722 /** 723 * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16). 724 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 725 * it will return zero. 726 */ 727 public int getPr116_ProcedureCodeModifierReps() { 728 return this.getReps(16); 729 } 730 731 732 /** 733 * Inserts a repetition of 734 * PR1-16: "Procedure Code Modifier" at a specific index 735 * 736 * @param rep The repetition index (0-indexed) 737 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 738 */ 739 public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 740 return (CE) super.insertRepetition(16, rep); 741 } 742 743 744 /** 745 * Inserts a repetition of 746 * PR1-16: "Procedure Code Modifier" at a specific index 747 * 748 * @param rep The repetition index (0-indexed) 749 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 750 */ 751 public CE insertPr116_ProcedureCodeModifier(int rep) throws HL7Exception { 752 return (CE) super.insertRepetition(16, rep); 753 } 754 755 756 /** 757 * Removes a repetition of 758 * PR1-16: "Procedure Code Modifier" at a specific index 759 * 760 * @param rep The repetition index (0-indexed) 761 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 762 */ 763 public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 764 return (CE) super.removeRepetition(16, rep); 765 } 766 767 768 /** 769 * Removes a repetition of 770 * PR1-16: "Procedure Code Modifier" at a specific index 771 * 772 * @param rep The repetition index (0-indexed) 773 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 774 */ 775 public CE removePr116_ProcedureCodeModifier(int rep) throws HL7Exception { 776 return (CE) super.removeRepetition(16, rep); 777 } 778 779 780 781 782 783 784 /** {@inheritDoc} */ 785 protected Type createNewTypeWithoutReflection(int field) { 786 switch (field) { 787 case 0: return new SI(getMessage()); 788 case 1: return new IS(getMessage(), new Integer( 89 )); 789 case 2: return new CE(getMessage()); 790 case 3: return new ST(getMessage()); 791 case 4: return new TS(getMessage()); 792 case 5: return new IS(getMessage(), new Integer( 230 )); 793 case 6: return new NM(getMessage()); 794 case 7: return new XCN(getMessage()); 795 case 8: return new IS(getMessage(), new Integer( 19 )); 796 case 9: return new NM(getMessage()); 797 case 10: return new XCN(getMessage()); 798 case 11: return new XCN(getMessage()); 799 case 12: return new CE(getMessage()); 800 case 13: return new NM(getMessage()); 801 case 14: return new CE(getMessage()); 802 case 15: return new CE(getMessage()); 803 default: return null; 804 } 805 } 806 807 808} 809