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 OBR message segment (OBR - observation request segment). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>OBR-1: Set ID - OBR (SI) <b>optional </b> 053 * <li>OBR-2: Placer Order Number (EI) <b>optional </b> 054 * <li>OBR-3: Filler Order Number (EI) <b>optional </b> 055 * <li>OBR-4: Universal Service ID (CE) <b> </b> 056 * <li>OBR-5: Priority-OBR (ID) <b>optional </b> 057 * <li>OBR-6: Requested Date/time (TS) <b>optional </b> 058 * <li>OBR-7: Observation Date/Time # (TS) <b>optional </b> 059 * <li>OBR-8: Observation End Date/Time # (TS) <b>optional </b> 060 * <li>OBR-9: Collection Volume * (CQ) <b>optional </b> 061 * <li>OBR-10: Collector Identifier * (XCN) <b>optional repeating</b> 062 * <li>OBR-11: Specimen Action Code * (ID) <b>optional </b> 063 * <li>OBR-12: Danger Code (CE) <b>optional </b> 064 * <li>OBR-13: Relevant Clinical Info. (ST) <b>optional </b> 065 * <li>OBR-14: Specimen Received Date/Time * (TS) <b>optional </b> 066 * <li>OBR-15: Specimen Source (SPS) <b>optional </b> 067 * <li>OBR-16: Ordering Provider (XCN) <b>optional repeating</b> 068 * <li>OBR-17: Order Callback Phone Number (XTN) <b>optional repeating</b> 069 * <li>OBR-18: Placer Field 1 (ST) <b>optional </b> 070 * <li>OBR-19: Placer Field 2 (ST) <b>optional </b> 071 * <li>OBR-20: Filler Field 1 + (ST) <b>optional </b> 072 * <li>OBR-21: Filler Field 2 + (ST) <b>optional </b> 073 * <li>OBR-22: Results Rpt/Status Chng - Date/Time + (TS) <b>optional </b> 074 * <li>OBR-23: Charge to Practice + (MOC) <b>optional </b> 075 * <li>OBR-24: Diagnostic Serv Sect ID (ID) <b>optional </b> 076 * <li>OBR-25: Result Status + (ID) <b>optional </b> 077 * <li>OBR-26: Parent Result + (PRL) <b>optional </b> 078 * <li>OBR-27: Quantity/Timing (TQ) <b>optional repeating</b> 079 * <li>OBR-28: Result Copies To (XCN) <b>optional repeating</b> 080 * <li>OBR-29: Parent Number (EIP) <b>optional </b> 081 * <li>OBR-30: Transportation Mode (ID) <b>optional </b> 082 * <li>OBR-31: Reason for Study (CE) <b>optional repeating</b> 083 * <li>OBR-32: Principal Result Interpreter + (NDL) <b>optional </b> 084 * <li>OBR-33: Assistant Result Interpreter + (NDL) <b>optional repeating</b> 085 * <li>OBR-34: Technician + (NDL) <b>optional repeating</b> 086 * <li>OBR-35: Transcriptionist + (NDL) <b>optional repeating</b> 087 * <li>OBR-36: Scheduled Date/Time + (TS) <b>optional </b> 088 * <li>OBR-37: Number of Sample Containers * (NM) <b>optional </b> 089 * <li>OBR-38: Transport Logistics of Collected Sample * (CE) <b>optional repeating</b> 090 * <li>OBR-39: Collector’s Comment * (CE) <b>optional repeating</b> 091 * <li>OBR-40: Transport Arrangement Responsibility (CE) <b>optional </b> 092 * <li>OBR-41: Transport Arranged (ID) <b>optional </b> 093 * <li>OBR-42: Escort Required (ID) <b>optional </b> 094 * <li>OBR-43: Planned Patient Transport Comment (CE) <b>optional repeating</b> 095 * <li>OBR-44: Procedure Code (CE) <b>optional </b> 096 * <li>OBR-45: Procedure Code Modifier (CE) <b>optional repeating</b> 097 * </ul> 098 */ 099@SuppressWarnings("unused") 100public class OBR extends AbstractSegment { 101 102 /** 103 * Creates a new OBR segment 104 */ 105 public OBR(Group parent, ModelClassFactory factory) { 106 super(parent, factory); 107 init(factory); 108 } 109 110 private void init(ModelClassFactory factory) { 111 try { 112 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - OBR"); 113 this.add(EI.class, false, 1, 22, new Object[]{ getMessage() }, "Placer Order Number"); 114 this.add(EI.class, false, 1, 22, new Object[]{ getMessage() }, "Filler Order Number"); 115 this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Universal Service ID"); 116 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(0) }, "Priority-OBR"); 117 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Requested Date/time"); 118 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Observation Date/Time #"); 119 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Observation End Date/Time #"); 120 this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Collection Volume *"); 121 this.add(XCN.class, false, 0, 60, new Object[]{ getMessage() }, "Collector Identifier *"); 122 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(65) }, "Specimen Action Code *"); 123 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Danger Code"); 124 this.add(ST.class, false, 1, 300, new Object[]{ getMessage() }, "Relevant Clinical Info."); 125 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Specimen Received Date/Time *"); 126 this.add(SPS.class, false, 1, 300, new Object[]{ getMessage() }, "Specimen Source"); 127 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Ordering Provider"); 128 this.add(XTN.class, false, 2, 40, new Object[]{ getMessage() }, "Order Callback Phone Number"); 129 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Placer Field 1"); 130 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Placer Field 2"); 131 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Filler Field 1 +"); 132 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Filler Field 2 +"); 133 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Results Rpt/Status Chng - Date/Time +"); 134 this.add(MOC.class, false, 1, 40, new Object[]{ getMessage() }, "Charge to Practice +"); 135 this.add(ID.class, false, 1, 10, new Object[]{ getMessage(), new Integer(74) }, "Diagnostic Serv Sect ID"); 136 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(123) }, "Result Status +"); 137 this.add(PRL.class, false, 1, 200, new Object[]{ getMessage() }, "Parent Result +"); 138 this.add(TQ.class, false, 0, 200, new Object[]{ getMessage() }, "Quantity/Timing"); 139 this.add(XCN.class, false, 5, 150, new Object[]{ getMessage() }, "Result Copies To"); 140 this.add(EIP.class, false, 1, 200, new Object[]{ getMessage() }, "Parent Number"); 141 this.add(ID.class, false, 1, 20, new Object[]{ getMessage(), new Integer(124) }, "Transportation Mode"); 142 this.add(CE.class, false, 0, 300, new Object[]{ getMessage() }, "Reason for Study"); 143 this.add(NDL.class, false, 1, 200, new Object[]{ getMessage() }, "Principal Result Interpreter +"); 144 this.add(NDL.class, false, 0, 200, new Object[]{ getMessage() }, "Assistant Result Interpreter +"); 145 this.add(NDL.class, false, 0, 200, new Object[]{ getMessage() }, "Technician +"); 146 this.add(NDL.class, false, 0, 200, new Object[]{ getMessage() }, "Transcriptionist +"); 147 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Scheduled Date/Time +"); 148 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Number of Sample Containers *"); 149 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Transport Logistics of Collected Sample *"); 150 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Collector’s Comment *"); 151 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Transport Arrangement Responsibility"); 152 this.add(ID.class, false, 1, 30, new Object[]{ getMessage(), new Integer(224) }, "Transport Arranged"); 153 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(225) }, "Escort Required"); 154 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Planned Patient Transport Comment"); 155 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Procedure Code"); 156 this.add(CE.class, false, 0, 80, new Object[]{ getMessage() }, "Procedure Code Modifier"); 157 } catch(HL7Exception e) { 158 log.error("Unexpected error creating OBR - this is probably a bug in the source code generator.", e); 159 } 160 } 161 162 163 164 /** 165 * Returns 166 * OBR-1: "Set ID - OBR" - creates it if necessary 167 */ 168 public SI getSetIDOBR() { 169 SI retVal = this.getTypedField(1, 0); 170 return retVal; 171 } 172 173 /** 174 * Returns 175 * OBR-1: "Set ID - OBR" - creates it if necessary 176 */ 177 public SI getObr1_SetIDOBR() { 178 SI retVal = this.getTypedField(1, 0); 179 return retVal; 180 } 181 182 183 184 /** 185 * Returns 186 * OBR-2: "Placer Order Number" - creates it if necessary 187 */ 188 public EI getPlacerOrderNumber() { 189 EI retVal = this.getTypedField(2, 0); 190 return retVal; 191 } 192 193 /** 194 * Returns 195 * OBR-2: "Placer Order Number" - creates it if necessary 196 */ 197 public EI getObr2_PlacerOrderNumber() { 198 EI retVal = this.getTypedField(2, 0); 199 return retVal; 200 } 201 202 203 204 /** 205 * Returns 206 * OBR-3: "Filler Order Number" - creates it if necessary 207 */ 208 public EI getFillerOrderNumber() { 209 EI retVal = this.getTypedField(3, 0); 210 return retVal; 211 } 212 213 /** 214 * Returns 215 * OBR-3: "Filler Order Number" - creates it if necessary 216 */ 217 public EI getObr3_FillerOrderNumber() { 218 EI retVal = this.getTypedField(3, 0); 219 return retVal; 220 } 221 222 223 224 /** 225 * Returns 226 * OBR-4: "Universal Service ID" - creates it if necessary 227 */ 228 public CE getUniversalServiceID() { 229 CE retVal = this.getTypedField(4, 0); 230 return retVal; 231 } 232 233 /** 234 * Returns 235 * OBR-4: "Universal Service ID" - creates it if necessary 236 */ 237 public CE getObr4_UniversalServiceID() { 238 CE retVal = this.getTypedField(4, 0); 239 return retVal; 240 } 241 242 243 244 /** 245 * Returns 246 * OBR-5: "Priority-OBR" - creates it if necessary 247 */ 248 public ID getPriorityOBR() { 249 ID retVal = this.getTypedField(5, 0); 250 return retVal; 251 } 252 253 /** 254 * Returns 255 * OBR-5: "Priority-OBR" - creates it if necessary 256 */ 257 public ID getObr5_PriorityOBR() { 258 ID retVal = this.getTypedField(5, 0); 259 return retVal; 260 } 261 262 263 264 /** 265 * Returns 266 * OBR-6: "Requested Date/time" - creates it if necessary 267 */ 268 public TS getRequestedDateTime() { 269 TS retVal = this.getTypedField(6, 0); 270 return retVal; 271 } 272 273 /** 274 * Returns 275 * OBR-6: "Requested Date/time" - creates it if necessary 276 */ 277 public TS getObr6_RequestedDateTime() { 278 TS retVal = this.getTypedField(6, 0); 279 return retVal; 280 } 281 282 283 284 /** 285 * Returns 286 * OBR-7: "Observation Date/Time #" - creates it if necessary 287 */ 288 public TS getObservationDateTime() { 289 TS retVal = this.getTypedField(7, 0); 290 return retVal; 291 } 292 293 /** 294 * Returns 295 * OBR-7: "Observation Date/Time #" - creates it if necessary 296 */ 297 public TS getObr7_ObservationDateTime() { 298 TS retVal = this.getTypedField(7, 0); 299 return retVal; 300 } 301 302 303 304 /** 305 * Returns 306 * OBR-8: "Observation End Date/Time #" - creates it if necessary 307 */ 308 public TS getObservationEndDateTime() { 309 TS retVal = this.getTypedField(8, 0); 310 return retVal; 311 } 312 313 /** 314 * Returns 315 * OBR-8: "Observation End Date/Time #" - creates it if necessary 316 */ 317 public TS getObr8_ObservationEndDateTime() { 318 TS retVal = this.getTypedField(8, 0); 319 return retVal; 320 } 321 322 323 324 /** 325 * Returns 326 * OBR-9: "Collection Volume *" - creates it if necessary 327 */ 328 public CQ getCollectionVolume() { 329 CQ retVal = this.getTypedField(9, 0); 330 return retVal; 331 } 332 333 /** 334 * Returns 335 * OBR-9: "Collection Volume *" - creates it if necessary 336 */ 337 public CQ getObr9_CollectionVolume() { 338 CQ retVal = this.getTypedField(9, 0); 339 return retVal; 340 } 341 342 343 /** 344 * Returns all repetitions of Collector Identifier * (OBR-10). 345 */ 346 public XCN[] getCollectorIdentifier() { 347 XCN[] retVal = this.getTypedField(10, new XCN[0]); 348 return retVal; 349 } 350 351 352 /** 353 * Returns all repetitions of Collector Identifier * (OBR-10). 354 */ 355 public XCN[] getObr10_CollectorIdentifier() { 356 XCN[] retVal = this.getTypedField(10, new XCN[0]); 357 return retVal; 358 } 359 360 361 /** 362 * Returns a count of the current number of repetitions of Collector Identifier * (OBR-10). 363 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 364 * it will return zero. 365 */ 366 public int getCollectorIdentifierReps() { 367 return this.getReps(10); 368 } 369 370 371 /** 372 * Returns a specific repetition of 373 * OBR-10: "Collector Identifier *" - creates it if necessary 374 * 375 * @param rep The repetition index (0-indexed) 376 */ 377 public XCN getCollectorIdentifier(int rep) { 378 XCN retVal = this.getTypedField(10, rep); 379 return retVal; 380 } 381 382 /** 383 * Returns a specific repetition of 384 * OBR-10: "Collector Identifier *" - creates it if necessary 385 * 386 * @param rep The repetition index (0-indexed) 387 */ 388 public XCN getObr10_CollectorIdentifier(int rep) { 389 XCN retVal = this.getTypedField(10, rep); 390 return retVal; 391 } 392 393 /** 394 * Returns a count of the current number of repetitions of Collector Identifier * (OBR-10). 395 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 396 * it will return zero. 397 */ 398 public int getObr10_CollectorIdentifierReps() { 399 return this.getReps(10); 400 } 401 402 403 /** 404 * Inserts a repetition of 405 * OBR-10: "Collector Identifier *" at a specific index 406 * 407 * @param rep The repetition index (0-indexed) 408 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 409 */ 410 public XCN insertCollectorIdentifier(int rep) throws HL7Exception { 411 return (XCN) super.insertRepetition(10, rep); 412 } 413 414 415 /** 416 * Inserts a repetition of 417 * OBR-10: "Collector Identifier *" at a specific index 418 * 419 * @param rep The repetition index (0-indexed) 420 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 421 */ 422 public XCN insertObr10_CollectorIdentifier(int rep) throws HL7Exception { 423 return (XCN) super.insertRepetition(10, rep); 424 } 425 426 427 /** 428 * Removes a repetition of 429 * OBR-10: "Collector Identifier *" at a specific index 430 * 431 * @param rep The repetition index (0-indexed) 432 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 433 */ 434 public XCN removeCollectorIdentifier(int rep) throws HL7Exception { 435 return (XCN) super.removeRepetition(10, rep); 436 } 437 438 439 /** 440 * Removes a repetition of 441 * OBR-10: "Collector Identifier *" at a specific index 442 * 443 * @param rep The repetition index (0-indexed) 444 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 445 */ 446 public XCN removeObr10_CollectorIdentifier(int rep) throws HL7Exception { 447 return (XCN) super.removeRepetition(10, rep); 448 } 449 450 451 452 453 /** 454 * Returns 455 * OBR-11: "Specimen Action Code *" - creates it if necessary 456 */ 457 public ID getSpecimenActionCode() { 458 ID retVal = this.getTypedField(11, 0); 459 return retVal; 460 } 461 462 /** 463 * Returns 464 * OBR-11: "Specimen Action Code *" - creates it if necessary 465 */ 466 public ID getObr11_SpecimenActionCode() { 467 ID retVal = this.getTypedField(11, 0); 468 return retVal; 469 } 470 471 472 473 /** 474 * Returns 475 * OBR-12: "Danger Code" - creates it if necessary 476 */ 477 public CE getDangerCode() { 478 CE retVal = this.getTypedField(12, 0); 479 return retVal; 480 } 481 482 /** 483 * Returns 484 * OBR-12: "Danger Code" - creates it if necessary 485 */ 486 public CE getObr12_DangerCode() { 487 CE retVal = this.getTypedField(12, 0); 488 return retVal; 489 } 490 491 492 493 /** 494 * Returns 495 * OBR-13: "Relevant Clinical Info." - creates it if necessary 496 */ 497 public ST getRelevantClinicalInfo() { 498 ST retVal = this.getTypedField(13, 0); 499 return retVal; 500 } 501 502 /** 503 * Returns 504 * OBR-13: "Relevant Clinical Info." - creates it if necessary 505 */ 506 public ST getObr13_RelevantClinicalInfo() { 507 ST retVal = this.getTypedField(13, 0); 508 return retVal; 509 } 510 511 512 513 /** 514 * Returns 515 * OBR-14: "Specimen Received Date/Time *" - creates it if necessary 516 */ 517 public TS getSpecimenReceivedDateTime() { 518 TS retVal = this.getTypedField(14, 0); 519 return retVal; 520 } 521 522 /** 523 * Returns 524 * OBR-14: "Specimen Received Date/Time *" - creates it if necessary 525 */ 526 public TS getObr14_SpecimenReceivedDateTime() { 527 TS retVal = this.getTypedField(14, 0); 528 return retVal; 529 } 530 531 532 533 /** 534 * Returns 535 * OBR-15: "Specimen Source" - creates it if necessary 536 */ 537 public SPS getSpecimenSource() { 538 SPS retVal = this.getTypedField(15, 0); 539 return retVal; 540 } 541 542 /** 543 * Returns 544 * OBR-15: "Specimen Source" - creates it if necessary 545 */ 546 public SPS getObr15_SpecimenSource() { 547 SPS retVal = this.getTypedField(15, 0); 548 return retVal; 549 } 550 551 552 /** 553 * Returns all repetitions of Ordering Provider (OBR-16). 554 */ 555 public XCN[] getOrderingProvider() { 556 XCN[] retVal = this.getTypedField(16, new XCN[0]); 557 return retVal; 558 } 559 560 561 /** 562 * Returns all repetitions of Ordering Provider (OBR-16). 563 */ 564 public XCN[] getObr16_OrderingProvider() { 565 XCN[] retVal = this.getTypedField(16, new XCN[0]); 566 return retVal; 567 } 568 569 570 /** 571 * Returns a count of the current number of repetitions of Ordering Provider (OBR-16). 572 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 573 * it will return zero. 574 */ 575 public int getOrderingProviderReps() { 576 return this.getReps(16); 577 } 578 579 580 /** 581 * Returns a specific repetition of 582 * OBR-16: "Ordering Provider" - creates it if necessary 583 * 584 * @param rep The repetition index (0-indexed) 585 */ 586 public XCN getOrderingProvider(int rep) { 587 XCN retVal = this.getTypedField(16, rep); 588 return retVal; 589 } 590 591 /** 592 * Returns a specific repetition of 593 * OBR-16: "Ordering Provider" - creates it if necessary 594 * 595 * @param rep The repetition index (0-indexed) 596 */ 597 public XCN getObr16_OrderingProvider(int rep) { 598 XCN retVal = this.getTypedField(16, rep); 599 return retVal; 600 } 601 602 /** 603 * Returns a count of the current number of repetitions of Ordering Provider (OBR-16). 604 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 605 * it will return zero. 606 */ 607 public int getObr16_OrderingProviderReps() { 608 return this.getReps(16); 609 } 610 611 612 /** 613 * Inserts a repetition of 614 * OBR-16: "Ordering Provider" at a specific index 615 * 616 * @param rep The repetition index (0-indexed) 617 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 618 */ 619 public XCN insertOrderingProvider(int rep) throws HL7Exception { 620 return (XCN) super.insertRepetition(16, rep); 621 } 622 623 624 /** 625 * Inserts a repetition of 626 * OBR-16: "Ordering Provider" at a specific index 627 * 628 * @param rep The repetition index (0-indexed) 629 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 630 */ 631 public XCN insertObr16_OrderingProvider(int rep) throws HL7Exception { 632 return (XCN) super.insertRepetition(16, rep); 633 } 634 635 636 /** 637 * Removes a repetition of 638 * OBR-16: "Ordering Provider" at a specific index 639 * 640 * @param rep The repetition index (0-indexed) 641 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 642 */ 643 public XCN removeOrderingProvider(int rep) throws HL7Exception { 644 return (XCN) super.removeRepetition(16, rep); 645 } 646 647 648 /** 649 * Removes a repetition of 650 * OBR-16: "Ordering Provider" at a specific index 651 * 652 * @param rep The repetition index (0-indexed) 653 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 654 */ 655 public XCN removeObr16_OrderingProvider(int rep) throws HL7Exception { 656 return (XCN) super.removeRepetition(16, rep); 657 } 658 659 660 661 /** 662 * Returns all repetitions of Order Callback Phone Number (OBR-17). 663 */ 664 public XTN[] getOrderCallbackPhoneNumber() { 665 XTN[] retVal = this.getTypedField(17, new XTN[0]); 666 return retVal; 667 } 668 669 670 /** 671 * Returns all repetitions of Order Callback Phone Number (OBR-17). 672 */ 673 public XTN[] getObr17_OrderCallbackPhoneNumber() { 674 XTN[] retVal = this.getTypedField(17, new XTN[0]); 675 return retVal; 676 } 677 678 679 /** 680 * Returns a count of the current number of repetitions of Order Callback Phone Number (OBR-17). 681 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 682 * it will return zero. 683 */ 684 public int getOrderCallbackPhoneNumberReps() { 685 return this.getReps(17); 686 } 687 688 689 /** 690 * Returns a specific repetition of 691 * OBR-17: "Order Callback Phone Number" - creates it if necessary 692 * 693 * @param rep The repetition index (0-indexed) 694 */ 695 public XTN getOrderCallbackPhoneNumber(int rep) { 696 XTN retVal = this.getTypedField(17, rep); 697 return retVal; 698 } 699 700 /** 701 * Returns a specific repetition of 702 * OBR-17: "Order Callback Phone Number" - creates it if necessary 703 * 704 * @param rep The repetition index (0-indexed) 705 */ 706 public XTN getObr17_OrderCallbackPhoneNumber(int rep) { 707 XTN retVal = this.getTypedField(17, rep); 708 return retVal; 709 } 710 711 /** 712 * Returns a count of the current number of repetitions of Order Callback Phone Number (OBR-17). 713 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 714 * it will return zero. 715 */ 716 public int getObr17_OrderCallbackPhoneNumberReps() { 717 return this.getReps(17); 718 } 719 720 721 /** 722 * Inserts a repetition of 723 * OBR-17: "Order Callback Phone Number" at a specific index 724 * 725 * @param rep The repetition index (0-indexed) 726 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 727 */ 728 public XTN insertOrderCallbackPhoneNumber(int rep) throws HL7Exception { 729 return (XTN) super.insertRepetition(17, rep); 730 } 731 732 733 /** 734 * Inserts a repetition of 735 * OBR-17: "Order Callback Phone Number" at a specific index 736 * 737 * @param rep The repetition index (0-indexed) 738 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 739 */ 740 public XTN insertObr17_OrderCallbackPhoneNumber(int rep) throws HL7Exception { 741 return (XTN) super.insertRepetition(17, rep); 742 } 743 744 745 /** 746 * Removes a repetition of 747 * OBR-17: "Order Callback Phone Number" at a specific index 748 * 749 * @param rep The repetition index (0-indexed) 750 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 751 */ 752 public XTN removeOrderCallbackPhoneNumber(int rep) throws HL7Exception { 753 return (XTN) super.removeRepetition(17, rep); 754 } 755 756 757 /** 758 * Removes a repetition of 759 * OBR-17: "Order Callback Phone Number" at a specific index 760 * 761 * @param rep The repetition index (0-indexed) 762 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 763 */ 764 public XTN removeObr17_OrderCallbackPhoneNumber(int rep) throws HL7Exception { 765 return (XTN) super.removeRepetition(17, rep); 766 } 767 768 769 770 771 /** 772 * Returns 773 * OBR-18: "Placer Field 1" - creates it if necessary 774 */ 775 public ST getPlacerField1() { 776 ST retVal = this.getTypedField(18, 0); 777 return retVal; 778 } 779 780 /** 781 * Returns 782 * OBR-18: "Placer Field 1" - creates it if necessary 783 */ 784 public ST getObr18_PlacerField1() { 785 ST retVal = this.getTypedField(18, 0); 786 return retVal; 787 } 788 789 790 791 /** 792 * Returns 793 * OBR-19: "Placer Field 2" - creates it if necessary 794 */ 795 public ST getPlacerField2() { 796 ST retVal = this.getTypedField(19, 0); 797 return retVal; 798 } 799 800 /** 801 * Returns 802 * OBR-19: "Placer Field 2" - creates it if necessary 803 */ 804 public ST getObr19_PlacerField2() { 805 ST retVal = this.getTypedField(19, 0); 806 return retVal; 807 } 808 809 810 811 /** 812 * Returns 813 * OBR-20: "Filler Field 1 +" - creates it if necessary 814 */ 815 public ST getFillerField1() { 816 ST retVal = this.getTypedField(20, 0); 817 return retVal; 818 } 819 820 /** 821 * Returns 822 * OBR-20: "Filler Field 1 +" - creates it if necessary 823 */ 824 public ST getObr20_FillerField1() { 825 ST retVal = this.getTypedField(20, 0); 826 return retVal; 827 } 828 829 830 831 /** 832 * Returns 833 * OBR-21: "Filler Field 2 +" - creates it if necessary 834 */ 835 public ST getFillerField2() { 836 ST retVal = this.getTypedField(21, 0); 837 return retVal; 838 } 839 840 /** 841 * Returns 842 * OBR-21: "Filler Field 2 +" - creates it if necessary 843 */ 844 public ST getObr21_FillerField2() { 845 ST retVal = this.getTypedField(21, 0); 846 return retVal; 847 } 848 849 850 851 /** 852 * Returns 853 * OBR-22: "Results Rpt/Status Chng - Date/Time +" - creates it if necessary 854 */ 855 public TS getResultsRptStatusChngDateTime() { 856 TS retVal = this.getTypedField(22, 0); 857 return retVal; 858 } 859 860 /** 861 * Returns 862 * OBR-22: "Results Rpt/Status Chng - Date/Time +" - creates it if necessary 863 */ 864 public TS getObr22_ResultsRptStatusChngDateTime() { 865 TS retVal = this.getTypedField(22, 0); 866 return retVal; 867 } 868 869 870 871 /** 872 * Returns 873 * OBR-23: "Charge to Practice +" - creates it if necessary 874 */ 875 public MOC getChargeToPractice() { 876 MOC retVal = this.getTypedField(23, 0); 877 return retVal; 878 } 879 880 /** 881 * Returns 882 * OBR-23: "Charge to Practice +" - creates it if necessary 883 */ 884 public MOC getObr23_ChargeToPractice() { 885 MOC retVal = this.getTypedField(23, 0); 886 return retVal; 887 } 888 889 890 891 /** 892 * Returns 893 * OBR-24: "Diagnostic Serv Sect ID" - creates it if necessary 894 */ 895 public ID getDiagnosticServSectID() { 896 ID retVal = this.getTypedField(24, 0); 897 return retVal; 898 } 899 900 /** 901 * Returns 902 * OBR-24: "Diagnostic Serv Sect ID" - creates it if necessary 903 */ 904 public ID getObr24_DiagnosticServSectID() { 905 ID retVal = this.getTypedField(24, 0); 906 return retVal; 907 } 908 909 910 911 /** 912 * Returns 913 * OBR-25: "Result Status +" - creates it if necessary 914 */ 915 public ID getResultStatus() { 916 ID retVal = this.getTypedField(25, 0); 917 return retVal; 918 } 919 920 /** 921 * Returns 922 * OBR-25: "Result Status +" - creates it if necessary 923 */ 924 public ID getObr25_ResultStatus() { 925 ID retVal = this.getTypedField(25, 0); 926 return retVal; 927 } 928 929 930 931 /** 932 * Returns 933 * OBR-26: "Parent Result +" - creates it if necessary 934 */ 935 public PRL getParentResult() { 936 PRL retVal = this.getTypedField(26, 0); 937 return retVal; 938 } 939 940 /** 941 * Returns 942 * OBR-26: "Parent Result +" - creates it if necessary 943 */ 944 public PRL getObr26_ParentResult() { 945 PRL retVal = this.getTypedField(26, 0); 946 return retVal; 947 } 948 949 950 /** 951 * Returns all repetitions of Quantity/Timing (OBR-27). 952 */ 953 public TQ[] getQuantityTiming() { 954 TQ[] retVal = this.getTypedField(27, new TQ[0]); 955 return retVal; 956 } 957 958 959 /** 960 * Returns all repetitions of Quantity/Timing (OBR-27). 961 */ 962 public TQ[] getObr27_QuantityTiming() { 963 TQ[] retVal = this.getTypedField(27, new TQ[0]); 964 return retVal; 965 } 966 967 968 /** 969 * Returns a count of the current number of repetitions of Quantity/Timing (OBR-27). 970 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 971 * it will return zero. 972 */ 973 public int getQuantityTimingReps() { 974 return this.getReps(27); 975 } 976 977 978 /** 979 * Returns a specific repetition of 980 * OBR-27: "Quantity/Timing" - creates it if necessary 981 * 982 * @param rep The repetition index (0-indexed) 983 */ 984 public TQ getQuantityTiming(int rep) { 985 TQ retVal = this.getTypedField(27, rep); 986 return retVal; 987 } 988 989 /** 990 * Returns a specific repetition of 991 * OBR-27: "Quantity/Timing" - creates it if necessary 992 * 993 * @param rep The repetition index (0-indexed) 994 */ 995 public TQ getObr27_QuantityTiming(int rep) { 996 TQ retVal = this.getTypedField(27, rep); 997 return retVal; 998 } 999 1000 /** 1001 * Returns a count of the current number of repetitions of Quantity/Timing (OBR-27). 1002 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1003 * it will return zero. 1004 */ 1005 public int getObr27_QuantityTimingReps() { 1006 return this.getReps(27); 1007 } 1008 1009 1010 /** 1011 * Inserts a repetition of 1012 * OBR-27: "Quantity/Timing" at a specific index 1013 * 1014 * @param rep The repetition index (0-indexed) 1015 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1016 */ 1017 public TQ insertQuantityTiming(int rep) throws HL7Exception { 1018 return (TQ) super.insertRepetition(27, rep); 1019 } 1020 1021 1022 /** 1023 * Inserts a repetition of 1024 * OBR-27: "Quantity/Timing" at a specific index 1025 * 1026 * @param rep The repetition index (0-indexed) 1027 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1028 */ 1029 public TQ insertObr27_QuantityTiming(int rep) throws HL7Exception { 1030 return (TQ) super.insertRepetition(27, rep); 1031 } 1032 1033 1034 /** 1035 * Removes a repetition of 1036 * OBR-27: "Quantity/Timing" at a specific index 1037 * 1038 * @param rep The repetition index (0-indexed) 1039 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1040 */ 1041 public TQ removeQuantityTiming(int rep) throws HL7Exception { 1042 return (TQ) super.removeRepetition(27, rep); 1043 } 1044 1045 1046 /** 1047 * Removes a repetition of 1048 * OBR-27: "Quantity/Timing" at a specific index 1049 * 1050 * @param rep The repetition index (0-indexed) 1051 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1052 */ 1053 public TQ removeObr27_QuantityTiming(int rep) throws HL7Exception { 1054 return (TQ) super.removeRepetition(27, rep); 1055 } 1056 1057 1058 1059 /** 1060 * Returns all repetitions of Result Copies To (OBR-28). 1061 */ 1062 public XCN[] getResultCopiesTo() { 1063 XCN[] retVal = this.getTypedField(28, new XCN[0]); 1064 return retVal; 1065 } 1066 1067 1068 /** 1069 * Returns all repetitions of Result Copies To (OBR-28). 1070 */ 1071 public XCN[] getObr28_ResultCopiesTo() { 1072 XCN[] retVal = this.getTypedField(28, new XCN[0]); 1073 return retVal; 1074 } 1075 1076 1077 /** 1078 * Returns a count of the current number of repetitions of Result Copies To (OBR-28). 1079 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1080 * it will return zero. 1081 */ 1082 public int getResultCopiesToReps() { 1083 return this.getReps(28); 1084 } 1085 1086 1087 /** 1088 * Returns a specific repetition of 1089 * OBR-28: "Result Copies To" - creates it if necessary 1090 * 1091 * @param rep The repetition index (0-indexed) 1092 */ 1093 public XCN getResultCopiesTo(int rep) { 1094 XCN retVal = this.getTypedField(28, rep); 1095 return retVal; 1096 } 1097 1098 /** 1099 * Returns a specific repetition of 1100 * OBR-28: "Result Copies To" - creates it if necessary 1101 * 1102 * @param rep The repetition index (0-indexed) 1103 */ 1104 public XCN getObr28_ResultCopiesTo(int rep) { 1105 XCN retVal = this.getTypedField(28, rep); 1106 return retVal; 1107 } 1108 1109 /** 1110 * Returns a count of the current number of repetitions of Result Copies To (OBR-28). 1111 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1112 * it will return zero. 1113 */ 1114 public int getObr28_ResultCopiesToReps() { 1115 return this.getReps(28); 1116 } 1117 1118 1119 /** 1120 * Inserts a repetition of 1121 * OBR-28: "Result Copies To" at a specific index 1122 * 1123 * @param rep The repetition index (0-indexed) 1124 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1125 */ 1126 public XCN insertResultCopiesTo(int rep) throws HL7Exception { 1127 return (XCN) super.insertRepetition(28, rep); 1128 } 1129 1130 1131 /** 1132 * Inserts a repetition of 1133 * OBR-28: "Result Copies To" at a specific index 1134 * 1135 * @param rep The repetition index (0-indexed) 1136 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1137 */ 1138 public XCN insertObr28_ResultCopiesTo(int rep) throws HL7Exception { 1139 return (XCN) super.insertRepetition(28, rep); 1140 } 1141 1142 1143 /** 1144 * Removes a repetition of 1145 * OBR-28: "Result Copies To" at a specific index 1146 * 1147 * @param rep The repetition index (0-indexed) 1148 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1149 */ 1150 public XCN removeResultCopiesTo(int rep) throws HL7Exception { 1151 return (XCN) super.removeRepetition(28, rep); 1152 } 1153 1154 1155 /** 1156 * Removes a repetition of 1157 * OBR-28: "Result Copies To" at a specific index 1158 * 1159 * @param rep The repetition index (0-indexed) 1160 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1161 */ 1162 public XCN removeObr28_ResultCopiesTo(int rep) throws HL7Exception { 1163 return (XCN) super.removeRepetition(28, rep); 1164 } 1165 1166 1167 1168 1169 /** 1170 * Returns 1171 * OBR-29: "Parent Number" - creates it if necessary 1172 */ 1173 public EIP getParentNumber() { 1174 EIP retVal = this.getTypedField(29, 0); 1175 return retVal; 1176 } 1177 1178 /** 1179 * Returns 1180 * OBR-29: "Parent Number" - creates it if necessary 1181 */ 1182 public EIP getObr29_ParentNumber() { 1183 EIP retVal = this.getTypedField(29, 0); 1184 return retVal; 1185 } 1186 1187 1188 1189 /** 1190 * Returns 1191 * OBR-30: "Transportation Mode" - creates it if necessary 1192 */ 1193 public ID getTransportationMode() { 1194 ID retVal = this.getTypedField(30, 0); 1195 return retVal; 1196 } 1197 1198 /** 1199 * Returns 1200 * OBR-30: "Transportation Mode" - creates it if necessary 1201 */ 1202 public ID getObr30_TransportationMode() { 1203 ID retVal = this.getTypedField(30, 0); 1204 return retVal; 1205 } 1206 1207 1208 /** 1209 * Returns all repetitions of Reason for Study (OBR-31). 1210 */ 1211 public CE[] getReasonForStudy() { 1212 CE[] retVal = this.getTypedField(31, new CE[0]); 1213 return retVal; 1214 } 1215 1216 1217 /** 1218 * Returns all repetitions of Reason for Study (OBR-31). 1219 */ 1220 public CE[] getObr31_ReasonForStudy() { 1221 CE[] retVal = this.getTypedField(31, new CE[0]); 1222 return retVal; 1223 } 1224 1225 1226 /** 1227 * Returns a count of the current number of repetitions of Reason for Study (OBR-31). 1228 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1229 * it will return zero. 1230 */ 1231 public int getReasonForStudyReps() { 1232 return this.getReps(31); 1233 } 1234 1235 1236 /** 1237 * Returns a specific repetition of 1238 * OBR-31: "Reason for Study" - creates it if necessary 1239 * 1240 * @param rep The repetition index (0-indexed) 1241 */ 1242 public CE getReasonForStudy(int rep) { 1243 CE retVal = this.getTypedField(31, rep); 1244 return retVal; 1245 } 1246 1247 /** 1248 * Returns a specific repetition of 1249 * OBR-31: "Reason for Study" - creates it if necessary 1250 * 1251 * @param rep The repetition index (0-indexed) 1252 */ 1253 public CE getObr31_ReasonForStudy(int rep) { 1254 CE retVal = this.getTypedField(31, rep); 1255 return retVal; 1256 } 1257 1258 /** 1259 * Returns a count of the current number of repetitions of Reason for Study (OBR-31). 1260 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1261 * it will return zero. 1262 */ 1263 public int getObr31_ReasonForStudyReps() { 1264 return this.getReps(31); 1265 } 1266 1267 1268 /** 1269 * Inserts a repetition of 1270 * OBR-31: "Reason for Study" at a specific index 1271 * 1272 * @param rep The repetition index (0-indexed) 1273 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1274 */ 1275 public CE insertReasonForStudy(int rep) throws HL7Exception { 1276 return (CE) super.insertRepetition(31, rep); 1277 } 1278 1279 1280 /** 1281 * Inserts a repetition of 1282 * OBR-31: "Reason for Study" at a specific index 1283 * 1284 * @param rep The repetition index (0-indexed) 1285 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1286 */ 1287 public CE insertObr31_ReasonForStudy(int rep) throws HL7Exception { 1288 return (CE) super.insertRepetition(31, rep); 1289 } 1290 1291 1292 /** 1293 * Removes a repetition of 1294 * OBR-31: "Reason for Study" at a specific index 1295 * 1296 * @param rep The repetition index (0-indexed) 1297 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1298 */ 1299 public CE removeReasonForStudy(int rep) throws HL7Exception { 1300 return (CE) super.removeRepetition(31, rep); 1301 } 1302 1303 1304 /** 1305 * Removes a repetition of 1306 * OBR-31: "Reason for Study" at a specific index 1307 * 1308 * @param rep The repetition index (0-indexed) 1309 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1310 */ 1311 public CE removeObr31_ReasonForStudy(int rep) throws HL7Exception { 1312 return (CE) super.removeRepetition(31, rep); 1313 } 1314 1315 1316 1317 1318 /** 1319 * Returns 1320 * OBR-32: "Principal Result Interpreter +" - creates it if necessary 1321 */ 1322 public NDL getPrincipalResultInterpreter() { 1323 NDL retVal = this.getTypedField(32, 0); 1324 return retVal; 1325 } 1326 1327 /** 1328 * Returns 1329 * OBR-32: "Principal Result Interpreter +" - creates it if necessary 1330 */ 1331 public NDL getObr32_PrincipalResultInterpreter() { 1332 NDL retVal = this.getTypedField(32, 0); 1333 return retVal; 1334 } 1335 1336 1337 /** 1338 * Returns all repetitions of Assistant Result Interpreter + (OBR-33). 1339 */ 1340 public NDL[] getAssistantResultInterpreter() { 1341 NDL[] retVal = this.getTypedField(33, new NDL[0]); 1342 return retVal; 1343 } 1344 1345 1346 /** 1347 * Returns all repetitions of Assistant Result Interpreter + (OBR-33). 1348 */ 1349 public NDL[] getObr33_AssistantResultInterpreter() { 1350 NDL[] retVal = this.getTypedField(33, new NDL[0]); 1351 return retVal; 1352 } 1353 1354 1355 /** 1356 * Returns a count of the current number of repetitions of Assistant Result Interpreter + (OBR-33). 1357 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1358 * it will return zero. 1359 */ 1360 public int getAssistantResultInterpreterReps() { 1361 return this.getReps(33); 1362 } 1363 1364 1365 /** 1366 * Returns a specific repetition of 1367 * OBR-33: "Assistant Result Interpreter +" - creates it if necessary 1368 * 1369 * @param rep The repetition index (0-indexed) 1370 */ 1371 public NDL getAssistantResultInterpreter(int rep) { 1372 NDL retVal = this.getTypedField(33, rep); 1373 return retVal; 1374 } 1375 1376 /** 1377 * Returns a specific repetition of 1378 * OBR-33: "Assistant Result Interpreter +" - creates it if necessary 1379 * 1380 * @param rep The repetition index (0-indexed) 1381 */ 1382 public NDL getObr33_AssistantResultInterpreter(int rep) { 1383 NDL retVal = this.getTypedField(33, rep); 1384 return retVal; 1385 } 1386 1387 /** 1388 * Returns a count of the current number of repetitions of Assistant Result Interpreter + (OBR-33). 1389 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1390 * it will return zero. 1391 */ 1392 public int getObr33_AssistantResultInterpreterReps() { 1393 return this.getReps(33); 1394 } 1395 1396 1397 /** 1398 * Inserts a repetition of 1399 * OBR-33: "Assistant Result Interpreter +" at a specific index 1400 * 1401 * @param rep The repetition index (0-indexed) 1402 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1403 */ 1404 public NDL insertAssistantResultInterpreter(int rep) throws HL7Exception { 1405 return (NDL) super.insertRepetition(33, rep); 1406 } 1407 1408 1409 /** 1410 * Inserts a repetition of 1411 * OBR-33: "Assistant Result Interpreter +" at a specific index 1412 * 1413 * @param rep The repetition index (0-indexed) 1414 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1415 */ 1416 public NDL insertObr33_AssistantResultInterpreter(int rep) throws HL7Exception { 1417 return (NDL) super.insertRepetition(33, rep); 1418 } 1419 1420 1421 /** 1422 * Removes a repetition of 1423 * OBR-33: "Assistant Result Interpreter +" at a specific index 1424 * 1425 * @param rep The repetition index (0-indexed) 1426 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1427 */ 1428 public NDL removeAssistantResultInterpreter(int rep) throws HL7Exception { 1429 return (NDL) super.removeRepetition(33, rep); 1430 } 1431 1432 1433 /** 1434 * Removes a repetition of 1435 * OBR-33: "Assistant Result Interpreter +" at a specific index 1436 * 1437 * @param rep The repetition index (0-indexed) 1438 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1439 */ 1440 public NDL removeObr33_AssistantResultInterpreter(int rep) throws HL7Exception { 1441 return (NDL) super.removeRepetition(33, rep); 1442 } 1443 1444 1445 1446 /** 1447 * Returns all repetitions of Technician + (OBR-34). 1448 */ 1449 public NDL[] getTechnician() { 1450 NDL[] retVal = this.getTypedField(34, new NDL[0]); 1451 return retVal; 1452 } 1453 1454 1455 /** 1456 * Returns all repetitions of Technician + (OBR-34). 1457 */ 1458 public NDL[] getObr34_Technician() { 1459 NDL[] retVal = this.getTypedField(34, new NDL[0]); 1460 return retVal; 1461 } 1462 1463 1464 /** 1465 * Returns a count of the current number of repetitions of Technician + (OBR-34). 1466 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1467 * it will return zero. 1468 */ 1469 public int getTechnicianReps() { 1470 return this.getReps(34); 1471 } 1472 1473 1474 /** 1475 * Returns a specific repetition of 1476 * OBR-34: "Technician +" - creates it if necessary 1477 * 1478 * @param rep The repetition index (0-indexed) 1479 */ 1480 public NDL getTechnician(int rep) { 1481 NDL retVal = this.getTypedField(34, rep); 1482 return retVal; 1483 } 1484 1485 /** 1486 * Returns a specific repetition of 1487 * OBR-34: "Technician +" - creates it if necessary 1488 * 1489 * @param rep The repetition index (0-indexed) 1490 */ 1491 public NDL getObr34_Technician(int rep) { 1492 NDL retVal = this.getTypedField(34, rep); 1493 return retVal; 1494 } 1495 1496 /** 1497 * Returns a count of the current number of repetitions of Technician + (OBR-34). 1498 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1499 * it will return zero. 1500 */ 1501 public int getObr34_TechnicianReps() { 1502 return this.getReps(34); 1503 } 1504 1505 1506 /** 1507 * Inserts a repetition of 1508 * OBR-34: "Technician +" at a specific index 1509 * 1510 * @param rep The repetition index (0-indexed) 1511 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1512 */ 1513 public NDL insertTechnician(int rep) throws HL7Exception { 1514 return (NDL) super.insertRepetition(34, rep); 1515 } 1516 1517 1518 /** 1519 * Inserts a repetition of 1520 * OBR-34: "Technician +" at a specific index 1521 * 1522 * @param rep The repetition index (0-indexed) 1523 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1524 */ 1525 public NDL insertObr34_Technician(int rep) throws HL7Exception { 1526 return (NDL) super.insertRepetition(34, rep); 1527 } 1528 1529 1530 /** 1531 * Removes a repetition of 1532 * OBR-34: "Technician +" at a specific index 1533 * 1534 * @param rep The repetition index (0-indexed) 1535 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1536 */ 1537 public NDL removeTechnician(int rep) throws HL7Exception { 1538 return (NDL) super.removeRepetition(34, rep); 1539 } 1540 1541 1542 /** 1543 * Removes a repetition of 1544 * OBR-34: "Technician +" at a specific index 1545 * 1546 * @param rep The repetition index (0-indexed) 1547 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1548 */ 1549 public NDL removeObr34_Technician(int rep) throws HL7Exception { 1550 return (NDL) super.removeRepetition(34, rep); 1551 } 1552 1553 1554 1555 /** 1556 * Returns all repetitions of Transcriptionist + (OBR-35). 1557 */ 1558 public NDL[] getTranscriptionist() { 1559 NDL[] retVal = this.getTypedField(35, new NDL[0]); 1560 return retVal; 1561 } 1562 1563 1564 /** 1565 * Returns all repetitions of Transcriptionist + (OBR-35). 1566 */ 1567 public NDL[] getObr35_Transcriptionist() { 1568 NDL[] retVal = this.getTypedField(35, new NDL[0]); 1569 return retVal; 1570 } 1571 1572 1573 /** 1574 * Returns a count of the current number of repetitions of Transcriptionist + (OBR-35). 1575 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1576 * it will return zero. 1577 */ 1578 public int getTranscriptionistReps() { 1579 return this.getReps(35); 1580 } 1581 1582 1583 /** 1584 * Returns a specific repetition of 1585 * OBR-35: "Transcriptionist +" - creates it if necessary 1586 * 1587 * @param rep The repetition index (0-indexed) 1588 */ 1589 public NDL getTranscriptionist(int rep) { 1590 NDL retVal = this.getTypedField(35, rep); 1591 return retVal; 1592 } 1593 1594 /** 1595 * Returns a specific repetition of 1596 * OBR-35: "Transcriptionist +" - creates it if necessary 1597 * 1598 * @param rep The repetition index (0-indexed) 1599 */ 1600 public NDL getObr35_Transcriptionist(int rep) { 1601 NDL retVal = this.getTypedField(35, rep); 1602 return retVal; 1603 } 1604 1605 /** 1606 * Returns a count of the current number of repetitions of Transcriptionist + (OBR-35). 1607 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1608 * it will return zero. 1609 */ 1610 public int getObr35_TranscriptionistReps() { 1611 return this.getReps(35); 1612 } 1613 1614 1615 /** 1616 * Inserts a repetition of 1617 * OBR-35: "Transcriptionist +" at a specific index 1618 * 1619 * @param rep The repetition index (0-indexed) 1620 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1621 */ 1622 public NDL insertTranscriptionist(int rep) throws HL7Exception { 1623 return (NDL) super.insertRepetition(35, rep); 1624 } 1625 1626 1627 /** 1628 * Inserts a repetition of 1629 * OBR-35: "Transcriptionist +" at a specific index 1630 * 1631 * @param rep The repetition index (0-indexed) 1632 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1633 */ 1634 public NDL insertObr35_Transcriptionist(int rep) throws HL7Exception { 1635 return (NDL) super.insertRepetition(35, rep); 1636 } 1637 1638 1639 /** 1640 * Removes a repetition of 1641 * OBR-35: "Transcriptionist +" at a specific index 1642 * 1643 * @param rep The repetition index (0-indexed) 1644 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1645 */ 1646 public NDL removeTranscriptionist(int rep) throws HL7Exception { 1647 return (NDL) super.removeRepetition(35, rep); 1648 } 1649 1650 1651 /** 1652 * Removes a repetition of 1653 * OBR-35: "Transcriptionist +" at a specific index 1654 * 1655 * @param rep The repetition index (0-indexed) 1656 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1657 */ 1658 public NDL removeObr35_Transcriptionist(int rep) throws HL7Exception { 1659 return (NDL) super.removeRepetition(35, rep); 1660 } 1661 1662 1663 1664 1665 /** 1666 * Returns 1667 * OBR-36: "Scheduled Date/Time +" - creates it if necessary 1668 */ 1669 public TS getScheduledDateTime() { 1670 TS retVal = this.getTypedField(36, 0); 1671 return retVal; 1672 } 1673 1674 /** 1675 * Returns 1676 * OBR-36: "Scheduled Date/Time +" - creates it if necessary 1677 */ 1678 public TS getObr36_ScheduledDateTime() { 1679 TS retVal = this.getTypedField(36, 0); 1680 return retVal; 1681 } 1682 1683 1684 1685 /** 1686 * Returns 1687 * OBR-37: "Number of Sample Containers *" - creates it if necessary 1688 */ 1689 public NM getNumberOfSampleContainers() { 1690 NM retVal = this.getTypedField(37, 0); 1691 return retVal; 1692 } 1693 1694 /** 1695 * Returns 1696 * OBR-37: "Number of Sample Containers *" - creates it if necessary 1697 */ 1698 public NM getObr37_NumberOfSampleContainers() { 1699 NM retVal = this.getTypedField(37, 0); 1700 return retVal; 1701 } 1702 1703 1704 /** 1705 * Returns all repetitions of Transport Logistics of Collected Sample * (OBR-38). 1706 */ 1707 public CE[] getTransportLogisticsOfCollectedSample() { 1708 CE[] retVal = this.getTypedField(38, new CE[0]); 1709 return retVal; 1710 } 1711 1712 1713 /** 1714 * Returns all repetitions of Transport Logistics of Collected Sample * (OBR-38). 1715 */ 1716 public CE[] getObr38_TransportLogisticsOfCollectedSample() { 1717 CE[] retVal = this.getTypedField(38, new CE[0]); 1718 return retVal; 1719 } 1720 1721 1722 /** 1723 * Returns a count of the current number of repetitions of Transport Logistics of Collected Sample * (OBR-38). 1724 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1725 * it will return zero. 1726 */ 1727 public int getTransportLogisticsOfCollectedSampleReps() { 1728 return this.getReps(38); 1729 } 1730 1731 1732 /** 1733 * Returns a specific repetition of 1734 * OBR-38: "Transport Logistics of Collected Sample *" - creates it if necessary 1735 * 1736 * @param rep The repetition index (0-indexed) 1737 */ 1738 public CE getTransportLogisticsOfCollectedSample(int rep) { 1739 CE retVal = this.getTypedField(38, rep); 1740 return retVal; 1741 } 1742 1743 /** 1744 * Returns a specific repetition of 1745 * OBR-38: "Transport Logistics of Collected Sample *" - creates it if necessary 1746 * 1747 * @param rep The repetition index (0-indexed) 1748 */ 1749 public CE getObr38_TransportLogisticsOfCollectedSample(int rep) { 1750 CE retVal = this.getTypedField(38, rep); 1751 return retVal; 1752 } 1753 1754 /** 1755 * Returns a count of the current number of repetitions of Transport Logistics of Collected Sample * (OBR-38). 1756 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1757 * it will return zero. 1758 */ 1759 public int getObr38_TransportLogisticsOfCollectedSampleReps() { 1760 return this.getReps(38); 1761 } 1762 1763 1764 /** 1765 * Inserts a repetition of 1766 * OBR-38: "Transport Logistics of Collected Sample *" at a specific index 1767 * 1768 * @param rep The repetition index (0-indexed) 1769 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1770 */ 1771 public CE insertTransportLogisticsOfCollectedSample(int rep) throws HL7Exception { 1772 return (CE) super.insertRepetition(38, rep); 1773 } 1774 1775 1776 /** 1777 * Inserts a repetition of 1778 * OBR-38: "Transport Logistics of Collected Sample *" at a specific index 1779 * 1780 * @param rep The repetition index (0-indexed) 1781 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1782 */ 1783 public CE insertObr38_TransportLogisticsOfCollectedSample(int rep) throws HL7Exception { 1784 return (CE) super.insertRepetition(38, rep); 1785 } 1786 1787 1788 /** 1789 * Removes a repetition of 1790 * OBR-38: "Transport Logistics of Collected Sample *" at a specific index 1791 * 1792 * @param rep The repetition index (0-indexed) 1793 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1794 */ 1795 public CE removeTransportLogisticsOfCollectedSample(int rep) throws HL7Exception { 1796 return (CE) super.removeRepetition(38, rep); 1797 } 1798 1799 1800 /** 1801 * Removes a repetition of 1802 * OBR-38: "Transport Logistics of Collected Sample *" at a specific index 1803 * 1804 * @param rep The repetition index (0-indexed) 1805 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1806 */ 1807 public CE removeObr38_TransportLogisticsOfCollectedSample(int rep) throws HL7Exception { 1808 return (CE) super.removeRepetition(38, rep); 1809 } 1810 1811 1812 1813 /** 1814 * Returns all repetitions of Collector’s Comment * (OBR-39). 1815 */ 1816 public CE[] getCollectorSComment() { 1817 CE[] retVal = this.getTypedField(39, new CE[0]); 1818 return retVal; 1819 } 1820 1821 1822 /** 1823 * Returns all repetitions of Collector’s Comment * (OBR-39). 1824 */ 1825 public CE[] getObr39_CollectorSComment() { 1826 CE[] retVal = this.getTypedField(39, new CE[0]); 1827 return retVal; 1828 } 1829 1830 1831 /** 1832 * Returns a count of the current number of repetitions of Collector’s Comment * (OBR-39). 1833 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1834 * it will return zero. 1835 */ 1836 public int getCollectorSCommentReps() { 1837 return this.getReps(39); 1838 } 1839 1840 1841 /** 1842 * Returns a specific repetition of 1843 * OBR-39: "Collector’s Comment *" - creates it if necessary 1844 * 1845 * @param rep The repetition index (0-indexed) 1846 */ 1847 public CE getCollectorSComment(int rep) { 1848 CE retVal = this.getTypedField(39, rep); 1849 return retVal; 1850 } 1851 1852 /** 1853 * Returns a specific repetition of 1854 * OBR-39: "Collector’s Comment *" - creates it if necessary 1855 * 1856 * @param rep The repetition index (0-indexed) 1857 */ 1858 public CE getObr39_CollectorSComment(int rep) { 1859 CE retVal = this.getTypedField(39, rep); 1860 return retVal; 1861 } 1862 1863 /** 1864 * Returns a count of the current number of repetitions of Collector’s Comment * (OBR-39). 1865 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1866 * it will return zero. 1867 */ 1868 public int getObr39_CollectorSCommentReps() { 1869 return this.getReps(39); 1870 } 1871 1872 1873 /** 1874 * Inserts a repetition of 1875 * OBR-39: "Collector’s Comment *" at a specific index 1876 * 1877 * @param rep The repetition index (0-indexed) 1878 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1879 */ 1880 public CE insertCollectorSComment(int rep) throws HL7Exception { 1881 return (CE) super.insertRepetition(39, rep); 1882 } 1883 1884 1885 /** 1886 * Inserts a repetition of 1887 * OBR-39: "Collector’s Comment *" at a specific index 1888 * 1889 * @param rep The repetition index (0-indexed) 1890 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1891 */ 1892 public CE insertObr39_CollectorSComment(int rep) throws HL7Exception { 1893 return (CE) super.insertRepetition(39, rep); 1894 } 1895 1896 1897 /** 1898 * Removes a repetition of 1899 * OBR-39: "Collector’s Comment *" at a specific index 1900 * 1901 * @param rep The repetition index (0-indexed) 1902 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1903 */ 1904 public CE removeCollectorSComment(int rep) throws HL7Exception { 1905 return (CE) super.removeRepetition(39, rep); 1906 } 1907 1908 1909 /** 1910 * Removes a repetition of 1911 * OBR-39: "Collector’s Comment *" at a specific index 1912 * 1913 * @param rep The repetition index (0-indexed) 1914 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1915 */ 1916 public CE removeObr39_CollectorSComment(int rep) throws HL7Exception { 1917 return (CE) super.removeRepetition(39, rep); 1918 } 1919 1920 1921 1922 1923 /** 1924 * Returns 1925 * OBR-40: "Transport Arrangement Responsibility" - creates it if necessary 1926 */ 1927 public CE getTransportArrangementResponsibility() { 1928 CE retVal = this.getTypedField(40, 0); 1929 return retVal; 1930 } 1931 1932 /** 1933 * Returns 1934 * OBR-40: "Transport Arrangement Responsibility" - creates it if necessary 1935 */ 1936 public CE getObr40_TransportArrangementResponsibility() { 1937 CE retVal = this.getTypedField(40, 0); 1938 return retVal; 1939 } 1940 1941 1942 1943 /** 1944 * Returns 1945 * OBR-41: "Transport Arranged" - creates it if necessary 1946 */ 1947 public ID getTransportArranged() { 1948 ID retVal = this.getTypedField(41, 0); 1949 return retVal; 1950 } 1951 1952 /** 1953 * Returns 1954 * OBR-41: "Transport Arranged" - creates it if necessary 1955 */ 1956 public ID getObr41_TransportArranged() { 1957 ID retVal = this.getTypedField(41, 0); 1958 return retVal; 1959 } 1960 1961 1962 1963 /** 1964 * Returns 1965 * OBR-42: "Escort Required" - creates it if necessary 1966 */ 1967 public ID getEscortRequired() { 1968 ID retVal = this.getTypedField(42, 0); 1969 return retVal; 1970 } 1971 1972 /** 1973 * Returns 1974 * OBR-42: "Escort Required" - creates it if necessary 1975 */ 1976 public ID getObr42_EscortRequired() { 1977 ID retVal = this.getTypedField(42, 0); 1978 return retVal; 1979 } 1980 1981 1982 /** 1983 * Returns all repetitions of Planned Patient Transport Comment (OBR-43). 1984 */ 1985 public CE[] getPlannedPatientTransportComment() { 1986 CE[] retVal = this.getTypedField(43, new CE[0]); 1987 return retVal; 1988 } 1989 1990 1991 /** 1992 * Returns all repetitions of Planned Patient Transport Comment (OBR-43). 1993 */ 1994 public CE[] getObr43_PlannedPatientTransportComment() { 1995 CE[] retVal = this.getTypedField(43, new CE[0]); 1996 return retVal; 1997 } 1998 1999 2000 /** 2001 * Returns a count of the current number of repetitions of Planned Patient Transport Comment (OBR-43). 2002 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2003 * it will return zero. 2004 */ 2005 public int getPlannedPatientTransportCommentReps() { 2006 return this.getReps(43); 2007 } 2008 2009 2010 /** 2011 * Returns a specific repetition of 2012 * OBR-43: "Planned Patient Transport Comment" - creates it if necessary 2013 * 2014 * @param rep The repetition index (0-indexed) 2015 */ 2016 public CE getPlannedPatientTransportComment(int rep) { 2017 CE retVal = this.getTypedField(43, rep); 2018 return retVal; 2019 } 2020 2021 /** 2022 * Returns a specific repetition of 2023 * OBR-43: "Planned Patient Transport Comment" - creates it if necessary 2024 * 2025 * @param rep The repetition index (0-indexed) 2026 */ 2027 public CE getObr43_PlannedPatientTransportComment(int rep) { 2028 CE retVal = this.getTypedField(43, rep); 2029 return retVal; 2030 } 2031 2032 /** 2033 * Returns a count of the current number of repetitions of Planned Patient Transport Comment (OBR-43). 2034 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2035 * it will return zero. 2036 */ 2037 public int getObr43_PlannedPatientTransportCommentReps() { 2038 return this.getReps(43); 2039 } 2040 2041 2042 /** 2043 * Inserts a repetition of 2044 * OBR-43: "Planned Patient Transport Comment" at a specific index 2045 * 2046 * @param rep The repetition index (0-indexed) 2047 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2048 */ 2049 public CE insertPlannedPatientTransportComment(int rep) throws HL7Exception { 2050 return (CE) super.insertRepetition(43, rep); 2051 } 2052 2053 2054 /** 2055 * Inserts a repetition of 2056 * OBR-43: "Planned Patient Transport Comment" at a specific index 2057 * 2058 * @param rep The repetition index (0-indexed) 2059 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2060 */ 2061 public CE insertObr43_PlannedPatientTransportComment(int rep) throws HL7Exception { 2062 return (CE) super.insertRepetition(43, rep); 2063 } 2064 2065 2066 /** 2067 * Removes a repetition of 2068 * OBR-43: "Planned Patient Transport Comment" at a specific index 2069 * 2070 * @param rep The repetition index (0-indexed) 2071 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2072 */ 2073 public CE removePlannedPatientTransportComment(int rep) throws HL7Exception { 2074 return (CE) super.removeRepetition(43, rep); 2075 } 2076 2077 2078 /** 2079 * Removes a repetition of 2080 * OBR-43: "Planned Patient Transport Comment" at a specific index 2081 * 2082 * @param rep The repetition index (0-indexed) 2083 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2084 */ 2085 public CE removeObr43_PlannedPatientTransportComment(int rep) throws HL7Exception { 2086 return (CE) super.removeRepetition(43, rep); 2087 } 2088 2089 2090 2091 2092 /** 2093 * Returns 2094 * OBR-44: "Procedure Code" - creates it if necessary 2095 */ 2096 public CE getProcedureCode() { 2097 CE retVal = this.getTypedField(44, 0); 2098 return retVal; 2099 } 2100 2101 /** 2102 * Returns 2103 * OBR-44: "Procedure Code" - creates it if necessary 2104 */ 2105 public CE getObr44_ProcedureCode() { 2106 CE retVal = this.getTypedField(44, 0); 2107 return retVal; 2108 } 2109 2110 2111 /** 2112 * Returns all repetitions of Procedure Code Modifier (OBR-45). 2113 */ 2114 public CE[] getProcedureCodeModifier() { 2115 CE[] retVal = this.getTypedField(45, new CE[0]); 2116 return retVal; 2117 } 2118 2119 2120 /** 2121 * Returns all repetitions of Procedure Code Modifier (OBR-45). 2122 */ 2123 public CE[] getObr45_ProcedureCodeModifier() { 2124 CE[] retVal = this.getTypedField(45, new CE[0]); 2125 return retVal; 2126 } 2127 2128 2129 /** 2130 * Returns a count of the current number of repetitions of Procedure Code Modifier (OBR-45). 2131 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2132 * it will return zero. 2133 */ 2134 public int getProcedureCodeModifierReps() { 2135 return this.getReps(45); 2136 } 2137 2138 2139 /** 2140 * Returns a specific repetition of 2141 * OBR-45: "Procedure Code Modifier" - creates it if necessary 2142 * 2143 * @param rep The repetition index (0-indexed) 2144 */ 2145 public CE getProcedureCodeModifier(int rep) { 2146 CE retVal = this.getTypedField(45, rep); 2147 return retVal; 2148 } 2149 2150 /** 2151 * Returns a specific repetition of 2152 * OBR-45: "Procedure Code Modifier" - creates it if necessary 2153 * 2154 * @param rep The repetition index (0-indexed) 2155 */ 2156 public CE getObr45_ProcedureCodeModifier(int rep) { 2157 CE retVal = this.getTypedField(45, rep); 2158 return retVal; 2159 } 2160 2161 /** 2162 * Returns a count of the current number of repetitions of Procedure Code Modifier (OBR-45). 2163 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2164 * it will return zero. 2165 */ 2166 public int getObr45_ProcedureCodeModifierReps() { 2167 return this.getReps(45); 2168 } 2169 2170 2171 /** 2172 * Inserts a repetition of 2173 * OBR-45: "Procedure Code Modifier" at a specific index 2174 * 2175 * @param rep The repetition index (0-indexed) 2176 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2177 */ 2178 public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 2179 return (CE) super.insertRepetition(45, rep); 2180 } 2181 2182 2183 /** 2184 * Inserts a repetition of 2185 * OBR-45: "Procedure Code Modifier" at a specific index 2186 * 2187 * @param rep The repetition index (0-indexed) 2188 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2189 */ 2190 public CE insertObr45_ProcedureCodeModifier(int rep) throws HL7Exception { 2191 return (CE) super.insertRepetition(45, rep); 2192 } 2193 2194 2195 /** 2196 * Removes a repetition of 2197 * OBR-45: "Procedure Code Modifier" at a specific index 2198 * 2199 * @param rep The repetition index (0-indexed) 2200 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2201 */ 2202 public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 2203 return (CE) super.removeRepetition(45, rep); 2204 } 2205 2206 2207 /** 2208 * Removes a repetition of 2209 * OBR-45: "Procedure Code Modifier" at a specific index 2210 * 2211 * @param rep The repetition index (0-indexed) 2212 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2213 */ 2214 public CE removeObr45_ProcedureCodeModifier(int rep) throws HL7Exception { 2215 return (CE) super.removeRepetition(45, rep); 2216 } 2217 2218 2219 2220 2221 2222 2223 /** {@inheritDoc} */ 2224 protected Type createNewTypeWithoutReflection(int field) { 2225 switch (field) { 2226 case 0: return new SI(getMessage()); 2227 case 1: return new EI(getMessage()); 2228 case 2: return new EI(getMessage()); 2229 case 3: return new CE(getMessage()); 2230 case 4: return new ID(getMessage(), new Integer( 0 )); 2231 case 5: return new TS(getMessage()); 2232 case 6: return new TS(getMessage()); 2233 case 7: return new TS(getMessage()); 2234 case 8: return new CQ(getMessage()); 2235 case 9: return new XCN(getMessage()); 2236 case 10: return new ID(getMessage(), new Integer( 65 )); 2237 case 11: return new CE(getMessage()); 2238 case 12: return new ST(getMessage()); 2239 case 13: return new TS(getMessage()); 2240 case 14: return new SPS(getMessage()); 2241 case 15: return new XCN(getMessage()); 2242 case 16: return new XTN(getMessage()); 2243 case 17: return new ST(getMessage()); 2244 case 18: return new ST(getMessage()); 2245 case 19: return new ST(getMessage()); 2246 case 20: return new ST(getMessage()); 2247 case 21: return new TS(getMessage()); 2248 case 22: return new MOC(getMessage()); 2249 case 23: return new ID(getMessage(), new Integer( 74 )); 2250 case 24: return new ID(getMessage(), new Integer( 123 )); 2251 case 25: return new PRL(getMessage()); 2252 case 26: return new TQ(getMessage()); 2253 case 27: return new XCN(getMessage()); 2254 case 28: return new EIP(getMessage()); 2255 case 29: return new ID(getMessage(), new Integer( 124 )); 2256 case 30: return new CE(getMessage()); 2257 case 31: return new NDL(getMessage()); 2258 case 32: return new NDL(getMessage()); 2259 case 33: return new NDL(getMessage()); 2260 case 34: return new NDL(getMessage()); 2261 case 35: return new TS(getMessage()); 2262 case 36: return new NM(getMessage()); 2263 case 37: return new CE(getMessage()); 2264 case 38: return new CE(getMessage()); 2265 case 39: return new CE(getMessage()); 2266 case 40: return new ID(getMessage(), new Integer( 224 )); 2267 case 41: return new ID(getMessage(), new Integer( 225 )); 2268 case 42: return new CE(getMessage()); 2269 case 43: return new CE(getMessage()); 2270 case 44: return new CE(getMessage()); 2271 default: return null; 2272 } 2273 } 2274 2275 2276} 2277