001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v25.segment; 035 036// import ca.uhn.hl7v2.model.v25.group.*; 037import ca.uhn.hl7v2.model.v25.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 OBX message segment (Observation/Result). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>OBX-1: Set ID - OBX (SI) <b>optional </b> 053 * <li>OBX-2: Value Type (ID) <b>optional </b> 054 * <li>OBX-3: Observation Identifier (CE) <b> </b> 055 * <li>OBX-4: Observation Sub-ID (ST) <b>optional </b> 056 * <li>OBX-5: Observation Value (Varies) <b>optional repeating</b> 057 * <li>OBX-6: Units (CE) <b>optional </b> 058 * <li>OBX-7: References Range (ST) <b>optional </b> 059 * <li>OBX-8: Abnormal Flags (IS) <b>optional repeating</b> 060 * <li>OBX-9: Probability (NM) <b>optional </b> 061 * <li>OBX-10: Nature of Abnormal Test (ID) <b>optional repeating</b> 062 * <li>OBX-11: Observation Result Status (ID) <b> </b> 063 * <li>OBX-12: Effective Date of Reference Range (TS) <b>optional </b> 064 * <li>OBX-13: User Defined Access Checks (ST) <b>optional </b> 065 * <li>OBX-14: Date/Time of the Observation (TS) <b>optional </b> 066 * <li>OBX-15: Producer's ID (CE) <b>optional </b> 067 * <li>OBX-16: Responsible Observer (XCN) <b>optional repeating</b> 068 * <li>OBX-17: Observation Method (CE) <b>optional repeating</b> 069 * <li>OBX-18: Equipment Instance Identifier (EI) <b>optional repeating</b> 070 * <li>OBX-19: Date/Time of the Analysis (TS) <b>optional </b> 071 * </ul> 072 */ 073@SuppressWarnings("unused") 074public class OBX extends AbstractSegment { 075 076 /** 077 * Creates a new OBX segment 078 */ 079 public OBX(Group parent, ModelClassFactory factory) { 080 super(parent, factory); 081 init(factory); 082 } 083 084 private void init(ModelClassFactory factory) { 085 try { 086 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - OBX"); 087 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(125) }, "Value Type"); 088 this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Observation Identifier"); 089 this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Observation Sub-ID"); 090 this.add(Varies.class, false, 0, 99999, new Object[]{ getMessage() }, "Observation Value"); 091 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Units"); 092 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "References Range"); 093 this.add(IS.class, false, 0, 5, new Object[]{ getMessage(), new Integer(78) }, "Abnormal Flags"); 094 this.add(NM.class, false, 1, 5, new Object[]{ getMessage() }, "Probability"); 095 this.add(ID.class, false, 0, 2, new Object[]{ getMessage(), new Integer(80) }, "Nature of Abnormal Test"); 096 this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(85) }, "Observation Result Status"); 097 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date of Reference Range"); 098 this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "User Defined Access Checks"); 099 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Observation"); 100 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Producer's ID"); 101 this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Responsible Observer"); 102 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Observation Method"); 103 this.add(EI.class, false, 0, 22, new Object[]{ getMessage() }, "Equipment Instance Identifier"); 104 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Analysis"); 105 } catch(HL7Exception e) { 106 log.error("Unexpected error creating OBX - this is probably a bug in the source code generator.", e); 107 } 108 } 109 110 111 112 /** 113 * Returns 114 * OBX-1: "Set ID - OBX" - creates it if necessary 115 */ 116 public SI getSetIDOBX() { 117 SI retVal = this.getTypedField(1, 0); 118 return retVal; 119 } 120 121 /** 122 * Returns 123 * OBX-1: "Set ID - OBX" - creates it if necessary 124 */ 125 public SI getObx1_SetIDOBX() { 126 SI retVal = this.getTypedField(1, 0); 127 return retVal; 128 } 129 130 131 132 /** 133 * Returns 134 * OBX-2: "Value Type" - creates it if necessary 135 */ 136 public ID getValueType() { 137 ID retVal = this.getTypedField(2, 0); 138 return retVal; 139 } 140 141 /** 142 * Returns 143 * OBX-2: "Value Type" - creates it if necessary 144 */ 145 public ID getObx2_ValueType() { 146 ID retVal = this.getTypedField(2, 0); 147 return retVal; 148 } 149 150 151 152 /** 153 * Returns 154 * OBX-3: "Observation Identifier" - creates it if necessary 155 */ 156 public CE getObservationIdentifier() { 157 CE retVal = this.getTypedField(3, 0); 158 return retVal; 159 } 160 161 /** 162 * Returns 163 * OBX-3: "Observation Identifier" - creates it if necessary 164 */ 165 public CE getObx3_ObservationIdentifier() { 166 CE retVal = this.getTypedField(3, 0); 167 return retVal; 168 } 169 170 171 172 /** 173 * Returns 174 * OBX-4: "Observation Sub-ID" - creates it if necessary 175 */ 176 public ST getObservationSubID() { 177 ST retVal = this.getTypedField(4, 0); 178 return retVal; 179 } 180 181 /** 182 * Returns 183 * OBX-4: "Observation Sub-ID" - creates it if necessary 184 */ 185 public ST getObx4_ObservationSubID() { 186 ST retVal = this.getTypedField(4, 0); 187 return retVal; 188 } 189 190 191 /** 192 * Returns all repetitions of Observation Value (OBX-5). 193 */ 194 public Varies[] getObservationValue() { 195 Varies[] retVal = this.getTypedField(5, new Varies[0]); 196 return retVal; 197 } 198 199 200 /** 201 * Returns all repetitions of Observation Value (OBX-5). 202 */ 203 public Varies[] getObx5_ObservationValue() { 204 Varies[] retVal = this.getTypedField(5, new Varies[0]); 205 return retVal; 206 } 207 208 209 /** 210 * Returns a count of the current number of repetitions of Observation Value (OBX-5). 211 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 212 * it will return zero. 213 */ 214 public int getObservationValueReps() { 215 return this.getReps(5); 216 } 217 218 219 /** 220 * Returns a specific repetition of 221 * OBX-5: "Observation Value" - creates it if necessary 222 * 223 * @param rep The repetition index (0-indexed) 224 */ 225 public Varies getObservationValue(int rep) { 226 Varies retVal = this.getTypedField(5, rep); 227 return retVal; 228 } 229 230 /** 231 * Returns a specific repetition of 232 * OBX-5: "Observation Value" - creates it if necessary 233 * 234 * @param rep The repetition index (0-indexed) 235 */ 236 public Varies getObx5_ObservationValue(int rep) { 237 Varies retVal = this.getTypedField(5, rep); 238 return retVal; 239 } 240 241 /** 242 * Returns a count of the current number of repetitions of Observation Value (OBX-5). 243 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 244 * it will return zero. 245 */ 246 public int getObx5_ObservationValueReps() { 247 return this.getReps(5); 248 } 249 250 251 /** 252 * Inserts a repetition of 253 * OBX-5: "Observation Value" at a specific index 254 * 255 * @param rep The repetition index (0-indexed) 256 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 257 */ 258 public Varies insertObservationValue(int rep) throws HL7Exception { 259 return (Varies) super.insertRepetition(5, rep); 260 } 261 262 263 /** 264 * Inserts a repetition of 265 * OBX-5: "Observation Value" at a specific index 266 * 267 * @param rep The repetition index (0-indexed) 268 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 269 */ 270 public Varies insertObx5_ObservationValue(int rep) throws HL7Exception { 271 return (Varies) super.insertRepetition(5, rep); 272 } 273 274 275 /** 276 * Removes a repetition of 277 * OBX-5: "Observation Value" at a specific index 278 * 279 * @param rep The repetition index (0-indexed) 280 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 281 */ 282 public Varies removeObservationValue(int rep) throws HL7Exception { 283 return (Varies) super.removeRepetition(5, rep); 284 } 285 286 287 /** 288 * Removes a repetition of 289 * OBX-5: "Observation Value" at a specific index 290 * 291 * @param rep The repetition index (0-indexed) 292 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 293 */ 294 public Varies removeObx5_ObservationValue(int rep) throws HL7Exception { 295 return (Varies) super.removeRepetition(5, rep); 296 } 297 298 299 300 301 /** 302 * Returns 303 * OBX-6: "Units" - creates it if necessary 304 */ 305 public CE getUnits() { 306 CE retVal = this.getTypedField(6, 0); 307 return retVal; 308 } 309 310 /** 311 * Returns 312 * OBX-6: "Units" - creates it if necessary 313 */ 314 public CE getObx6_Units() { 315 CE retVal = this.getTypedField(6, 0); 316 return retVal; 317 } 318 319 320 321 /** 322 * Returns 323 * OBX-7: "References Range" - creates it if necessary 324 */ 325 public ST getReferencesRange() { 326 ST retVal = this.getTypedField(7, 0); 327 return retVal; 328 } 329 330 /** 331 * Returns 332 * OBX-7: "References Range" - creates it if necessary 333 */ 334 public ST getObx7_ReferencesRange() { 335 ST retVal = this.getTypedField(7, 0); 336 return retVal; 337 } 338 339 340 /** 341 * Returns all repetitions of Abnormal Flags (OBX-8). 342 */ 343 public IS[] getAbnormalFlags() { 344 IS[] retVal = this.getTypedField(8, new IS[0]); 345 return retVal; 346 } 347 348 349 /** 350 * Returns all repetitions of Abnormal Flags (OBX-8). 351 */ 352 public IS[] getObx8_AbnormalFlags() { 353 IS[] retVal = this.getTypedField(8, new IS[0]); 354 return retVal; 355 } 356 357 358 /** 359 * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8). 360 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 361 * it will return zero. 362 */ 363 public int getAbnormalFlagsReps() { 364 return this.getReps(8); 365 } 366 367 368 /** 369 * Returns a specific repetition of 370 * OBX-8: "Abnormal Flags" - creates it if necessary 371 * 372 * @param rep The repetition index (0-indexed) 373 */ 374 public IS getAbnormalFlags(int rep) { 375 IS retVal = this.getTypedField(8, rep); 376 return retVal; 377 } 378 379 /** 380 * Returns a specific repetition of 381 * OBX-8: "Abnormal Flags" - creates it if necessary 382 * 383 * @param rep The repetition index (0-indexed) 384 */ 385 public IS getObx8_AbnormalFlags(int rep) { 386 IS retVal = this.getTypedField(8, rep); 387 return retVal; 388 } 389 390 /** 391 * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8). 392 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 393 * it will return zero. 394 */ 395 public int getObx8_AbnormalFlagsReps() { 396 return this.getReps(8); 397 } 398 399 400 /** 401 * Inserts a repetition of 402 * OBX-8: "Abnormal Flags" at a specific index 403 * 404 * @param rep The repetition index (0-indexed) 405 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 406 */ 407 public IS insertAbnormalFlags(int rep) throws HL7Exception { 408 return (IS) super.insertRepetition(8, rep); 409 } 410 411 412 /** 413 * Inserts a repetition of 414 * OBX-8: "Abnormal Flags" at a specific index 415 * 416 * @param rep The repetition index (0-indexed) 417 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 418 */ 419 public IS insertObx8_AbnormalFlags(int rep) throws HL7Exception { 420 return (IS) super.insertRepetition(8, rep); 421 } 422 423 424 /** 425 * Removes a repetition of 426 * OBX-8: "Abnormal Flags" at a specific index 427 * 428 * @param rep The repetition index (0-indexed) 429 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 430 */ 431 public IS removeAbnormalFlags(int rep) throws HL7Exception { 432 return (IS) super.removeRepetition(8, rep); 433 } 434 435 436 /** 437 * Removes a repetition of 438 * OBX-8: "Abnormal Flags" at a specific index 439 * 440 * @param rep The repetition index (0-indexed) 441 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 442 */ 443 public IS removeObx8_AbnormalFlags(int rep) throws HL7Exception { 444 return (IS) super.removeRepetition(8, rep); 445 } 446 447 448 449 450 /** 451 * Returns 452 * OBX-9: "Probability" - creates it if necessary 453 */ 454 public NM getProbability() { 455 NM retVal = this.getTypedField(9, 0); 456 return retVal; 457 } 458 459 /** 460 * Returns 461 * OBX-9: "Probability" - creates it if necessary 462 */ 463 public NM getObx9_Probability() { 464 NM retVal = this.getTypedField(9, 0); 465 return retVal; 466 } 467 468 469 /** 470 * Returns all repetitions of Nature of Abnormal Test (OBX-10). 471 */ 472 public ID[] getNatureOfAbnormalTest() { 473 ID[] retVal = this.getTypedField(10, new ID[0]); 474 return retVal; 475 } 476 477 478 /** 479 * Returns all repetitions of Nature of Abnormal Test (OBX-10). 480 */ 481 public ID[] getObx10_NatureOfAbnormalTest() { 482 ID[] retVal = this.getTypedField(10, new ID[0]); 483 return retVal; 484 } 485 486 487 /** 488 * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10). 489 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 490 * it will return zero. 491 */ 492 public int getNatureOfAbnormalTestReps() { 493 return this.getReps(10); 494 } 495 496 497 /** 498 * Returns a specific repetition of 499 * OBX-10: "Nature of Abnormal Test" - creates it if necessary 500 * 501 * @param rep The repetition index (0-indexed) 502 */ 503 public ID getNatureOfAbnormalTest(int rep) { 504 ID retVal = this.getTypedField(10, rep); 505 return retVal; 506 } 507 508 /** 509 * Returns a specific repetition of 510 * OBX-10: "Nature of Abnormal Test" - creates it if necessary 511 * 512 * @param rep The repetition index (0-indexed) 513 */ 514 public ID getObx10_NatureOfAbnormalTest(int rep) { 515 ID retVal = this.getTypedField(10, rep); 516 return retVal; 517 } 518 519 /** 520 * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10). 521 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 522 * it will return zero. 523 */ 524 public int getObx10_NatureOfAbnormalTestReps() { 525 return this.getReps(10); 526 } 527 528 529 /** 530 * Inserts a repetition of 531 * OBX-10: "Nature of Abnormal Test" at a specific index 532 * 533 * @param rep The repetition index (0-indexed) 534 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 535 */ 536 public ID insertNatureOfAbnormalTest(int rep) throws HL7Exception { 537 return (ID) super.insertRepetition(10, rep); 538 } 539 540 541 /** 542 * Inserts a repetition of 543 * OBX-10: "Nature of Abnormal Test" at a specific index 544 * 545 * @param rep The repetition index (0-indexed) 546 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 547 */ 548 public ID insertObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { 549 return (ID) super.insertRepetition(10, rep); 550 } 551 552 553 /** 554 * Removes a repetition of 555 * OBX-10: "Nature of Abnormal Test" at a specific index 556 * 557 * @param rep The repetition index (0-indexed) 558 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 559 */ 560 public ID removeNatureOfAbnormalTest(int rep) throws HL7Exception { 561 return (ID) super.removeRepetition(10, rep); 562 } 563 564 565 /** 566 * Removes a repetition of 567 * OBX-10: "Nature of Abnormal Test" at a specific index 568 * 569 * @param rep The repetition index (0-indexed) 570 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 571 */ 572 public ID removeObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { 573 return (ID) super.removeRepetition(10, rep); 574 } 575 576 577 578 579 /** 580 * Returns 581 * OBX-11: "Observation Result Status" - creates it if necessary 582 */ 583 public ID getObservationResultStatus() { 584 ID retVal = this.getTypedField(11, 0); 585 return retVal; 586 } 587 588 /** 589 * Returns 590 * OBX-11: "Observation Result Status" - creates it if necessary 591 */ 592 public ID getObx11_ObservationResultStatus() { 593 ID retVal = this.getTypedField(11, 0); 594 return retVal; 595 } 596 597 598 599 /** 600 * Returns 601 * OBX-12: "Effective Date of Reference Range" - creates it if necessary 602 */ 603 public TS getEffectiveDateOfReferenceRange() { 604 TS retVal = this.getTypedField(12, 0); 605 return retVal; 606 } 607 608 /** 609 * Returns 610 * OBX-12: "Effective Date of Reference Range" - creates it if necessary 611 */ 612 public TS getObx12_EffectiveDateOfReferenceRange() { 613 TS retVal = this.getTypedField(12, 0); 614 return retVal; 615 } 616 617 618 619 /** 620 * Returns 621 * OBX-13: "User Defined Access Checks" - creates it if necessary 622 */ 623 public ST getUserDefinedAccessChecks() { 624 ST retVal = this.getTypedField(13, 0); 625 return retVal; 626 } 627 628 /** 629 * Returns 630 * OBX-13: "User Defined Access Checks" - creates it if necessary 631 */ 632 public ST getObx13_UserDefinedAccessChecks() { 633 ST retVal = this.getTypedField(13, 0); 634 return retVal; 635 } 636 637 638 639 /** 640 * Returns 641 * OBX-14: "Date/Time of the Observation" - creates it if necessary 642 */ 643 public TS getDateTimeOfTheObservation() { 644 TS retVal = this.getTypedField(14, 0); 645 return retVal; 646 } 647 648 /** 649 * Returns 650 * OBX-14: "Date/Time of the Observation" - creates it if necessary 651 */ 652 public TS getObx14_DateTimeOfTheObservation() { 653 TS retVal = this.getTypedField(14, 0); 654 return retVal; 655 } 656 657 658 659 /** 660 * Returns 661 * OBX-15: "Producer's ID" - creates it if necessary 662 */ 663 public CE getProducerSID() { 664 CE retVal = this.getTypedField(15, 0); 665 return retVal; 666 } 667 668 /** 669 * Returns 670 * OBX-15: "Producer's ID" - creates it if necessary 671 */ 672 public CE getObx15_ProducerSID() { 673 CE retVal = this.getTypedField(15, 0); 674 return retVal; 675 } 676 677 678 /** 679 * Returns all repetitions of Responsible Observer (OBX-16). 680 */ 681 public XCN[] getResponsibleObserver() { 682 XCN[] retVal = this.getTypedField(16, new XCN[0]); 683 return retVal; 684 } 685 686 687 /** 688 * Returns all repetitions of Responsible Observer (OBX-16). 689 */ 690 public XCN[] getObx16_ResponsibleObserver() { 691 XCN[] retVal = this.getTypedField(16, new XCN[0]); 692 return retVal; 693 } 694 695 696 /** 697 * Returns a count of the current number of repetitions of Responsible Observer (OBX-16). 698 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 699 * it will return zero. 700 */ 701 public int getResponsibleObserverReps() { 702 return this.getReps(16); 703 } 704 705 706 /** 707 * Returns a specific repetition of 708 * OBX-16: "Responsible Observer" - creates it if necessary 709 * 710 * @param rep The repetition index (0-indexed) 711 */ 712 public XCN getResponsibleObserver(int rep) { 713 XCN retVal = this.getTypedField(16, rep); 714 return retVal; 715 } 716 717 /** 718 * Returns a specific repetition of 719 * OBX-16: "Responsible Observer" - creates it if necessary 720 * 721 * @param rep The repetition index (0-indexed) 722 */ 723 public XCN getObx16_ResponsibleObserver(int rep) { 724 XCN retVal = this.getTypedField(16, rep); 725 return retVal; 726 } 727 728 /** 729 * Returns a count of the current number of repetitions of Responsible Observer (OBX-16). 730 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 731 * it will return zero. 732 */ 733 public int getObx16_ResponsibleObserverReps() { 734 return this.getReps(16); 735 } 736 737 738 /** 739 * Inserts a repetition of 740 * OBX-16: "Responsible Observer" at a specific index 741 * 742 * @param rep The repetition index (0-indexed) 743 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 744 */ 745 public XCN insertResponsibleObserver(int rep) throws HL7Exception { 746 return (XCN) super.insertRepetition(16, rep); 747 } 748 749 750 /** 751 * Inserts a repetition of 752 * OBX-16: "Responsible Observer" at a specific index 753 * 754 * @param rep The repetition index (0-indexed) 755 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 756 */ 757 public XCN insertObx16_ResponsibleObserver(int rep) throws HL7Exception { 758 return (XCN) super.insertRepetition(16, rep); 759 } 760 761 762 /** 763 * Removes a repetition of 764 * OBX-16: "Responsible Observer" at a specific index 765 * 766 * @param rep The repetition index (0-indexed) 767 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 768 */ 769 public XCN removeResponsibleObserver(int rep) throws HL7Exception { 770 return (XCN) super.removeRepetition(16, rep); 771 } 772 773 774 /** 775 * Removes a repetition of 776 * OBX-16: "Responsible Observer" at a specific index 777 * 778 * @param rep The repetition index (0-indexed) 779 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 780 */ 781 public XCN removeObx16_ResponsibleObserver(int rep) throws HL7Exception { 782 return (XCN) super.removeRepetition(16, rep); 783 } 784 785 786 787 /** 788 * Returns all repetitions of Observation Method (OBX-17). 789 */ 790 public CE[] getObservationMethod() { 791 CE[] retVal = this.getTypedField(17, new CE[0]); 792 return retVal; 793 } 794 795 796 /** 797 * Returns all repetitions of Observation Method (OBX-17). 798 */ 799 public CE[] getObx17_ObservationMethod() { 800 CE[] retVal = this.getTypedField(17, new CE[0]); 801 return retVal; 802 } 803 804 805 /** 806 * Returns a count of the current number of repetitions of Observation Method (OBX-17). 807 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 808 * it will return zero. 809 */ 810 public int getObservationMethodReps() { 811 return this.getReps(17); 812 } 813 814 815 /** 816 * Returns a specific repetition of 817 * OBX-17: "Observation Method" - creates it if necessary 818 * 819 * @param rep The repetition index (0-indexed) 820 */ 821 public CE getObservationMethod(int rep) { 822 CE retVal = this.getTypedField(17, rep); 823 return retVal; 824 } 825 826 /** 827 * Returns a specific repetition of 828 * OBX-17: "Observation Method" - creates it if necessary 829 * 830 * @param rep The repetition index (0-indexed) 831 */ 832 public CE getObx17_ObservationMethod(int rep) { 833 CE retVal = this.getTypedField(17, rep); 834 return retVal; 835 } 836 837 /** 838 * Returns a count of the current number of repetitions of Observation Method (OBX-17). 839 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 840 * it will return zero. 841 */ 842 public int getObx17_ObservationMethodReps() { 843 return this.getReps(17); 844 } 845 846 847 /** 848 * Inserts a repetition of 849 * OBX-17: "Observation Method" at a specific index 850 * 851 * @param rep The repetition index (0-indexed) 852 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 853 */ 854 public CE insertObservationMethod(int rep) throws HL7Exception { 855 return (CE) super.insertRepetition(17, rep); 856 } 857 858 859 /** 860 * Inserts a repetition of 861 * OBX-17: "Observation Method" at a specific index 862 * 863 * @param rep The repetition index (0-indexed) 864 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 865 */ 866 public CE insertObx17_ObservationMethod(int rep) throws HL7Exception { 867 return (CE) super.insertRepetition(17, rep); 868 } 869 870 871 /** 872 * Removes a repetition of 873 * OBX-17: "Observation Method" at a specific index 874 * 875 * @param rep The repetition index (0-indexed) 876 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 877 */ 878 public CE removeObservationMethod(int rep) throws HL7Exception { 879 return (CE) super.removeRepetition(17, rep); 880 } 881 882 883 /** 884 * Removes a repetition of 885 * OBX-17: "Observation Method" at a specific index 886 * 887 * @param rep The repetition index (0-indexed) 888 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 889 */ 890 public CE removeObx17_ObservationMethod(int rep) throws HL7Exception { 891 return (CE) super.removeRepetition(17, rep); 892 } 893 894 895 896 /** 897 * Returns all repetitions of Equipment Instance Identifier (OBX-18). 898 */ 899 public EI[] getEquipmentInstanceIdentifier() { 900 EI[] retVal = this.getTypedField(18, new EI[0]); 901 return retVal; 902 } 903 904 905 /** 906 * Returns all repetitions of Equipment Instance Identifier (OBX-18). 907 */ 908 public EI[] getObx18_EquipmentInstanceIdentifier() { 909 EI[] retVal = this.getTypedField(18, new EI[0]); 910 return retVal; 911 } 912 913 914 /** 915 * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18). 916 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 917 * it will return zero. 918 */ 919 public int getEquipmentInstanceIdentifierReps() { 920 return this.getReps(18); 921 } 922 923 924 /** 925 * Returns a specific repetition of 926 * OBX-18: "Equipment Instance Identifier" - creates it if necessary 927 * 928 * @param rep The repetition index (0-indexed) 929 */ 930 public EI getEquipmentInstanceIdentifier(int rep) { 931 EI retVal = this.getTypedField(18, rep); 932 return retVal; 933 } 934 935 /** 936 * Returns a specific repetition of 937 * OBX-18: "Equipment Instance Identifier" - creates it if necessary 938 * 939 * @param rep The repetition index (0-indexed) 940 */ 941 public EI getObx18_EquipmentInstanceIdentifier(int rep) { 942 EI retVal = this.getTypedField(18, rep); 943 return retVal; 944 } 945 946 /** 947 * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18). 948 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 949 * it will return zero. 950 */ 951 public int getObx18_EquipmentInstanceIdentifierReps() { 952 return this.getReps(18); 953 } 954 955 956 /** 957 * Inserts a repetition of 958 * OBX-18: "Equipment Instance Identifier" at a specific index 959 * 960 * @param rep The repetition index (0-indexed) 961 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 962 */ 963 public EI insertEquipmentInstanceIdentifier(int rep) throws HL7Exception { 964 return (EI) super.insertRepetition(18, rep); 965 } 966 967 968 /** 969 * Inserts a repetition of 970 * OBX-18: "Equipment Instance Identifier" at a specific index 971 * 972 * @param rep The repetition index (0-indexed) 973 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 974 */ 975 public EI insertObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { 976 return (EI) super.insertRepetition(18, rep); 977 } 978 979 980 /** 981 * Removes a repetition of 982 * OBX-18: "Equipment Instance Identifier" at a specific index 983 * 984 * @param rep The repetition index (0-indexed) 985 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 986 */ 987 public EI removeEquipmentInstanceIdentifier(int rep) throws HL7Exception { 988 return (EI) super.removeRepetition(18, rep); 989 } 990 991 992 /** 993 * Removes a repetition of 994 * OBX-18: "Equipment Instance Identifier" at a specific index 995 * 996 * @param rep The repetition index (0-indexed) 997 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 998 */ 999 public EI removeObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { 1000 return (EI) super.removeRepetition(18, rep); 1001 } 1002 1003 1004 1005 1006 /** 1007 * Returns 1008 * OBX-19: "Date/Time of the Analysis" - creates it if necessary 1009 */ 1010 public TS getDateTimeOfTheAnalysis() { 1011 TS retVal = this.getTypedField(19, 0); 1012 return retVal; 1013 } 1014 1015 /** 1016 * Returns 1017 * OBX-19: "Date/Time of the Analysis" - creates it if necessary 1018 */ 1019 public TS getObx19_DateTimeOfTheAnalysis() { 1020 TS retVal = this.getTypedField(19, 0); 1021 return retVal; 1022 } 1023 1024 1025 1026 1027 1028 /** {@inheritDoc} */ 1029 protected Type createNewTypeWithoutReflection(int field) { 1030 switch (field) { 1031 case 0: return new SI(getMessage()); 1032 case 1: return new ID(getMessage(), new Integer( 125 )); 1033 case 2: return new CE(getMessage()); 1034 case 3: return new ST(getMessage()); 1035 case 4: return new Varies(getMessage()); 1036 case 5: return new CE(getMessage()); 1037 case 6: return new ST(getMessage()); 1038 case 7: return new IS(getMessage(), new Integer( 78 )); 1039 case 8: return new NM(getMessage()); 1040 case 9: return new ID(getMessage(), new Integer( 80 )); 1041 case 10: return new ID(getMessage(), new Integer( 85 )); 1042 case 11: return new TS(getMessage()); 1043 case 12: return new ST(getMessage()); 1044 case 13: return new TS(getMessage()); 1045 case 14: return new CE(getMessage()); 1046 case 15: return new XCN(getMessage()); 1047 case 16: return new CE(getMessage()); 1048 case 17: return new EI(getMessage()); 1049 case 18: return new TS(getMessage()); 1050 default: return null; 1051 } 1052 } 1053 1054 1055} 1056