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.v23.segment; 035 036// import ca.uhn.hl7v2.model.v23.group.*; 037import ca.uhn.hl7v2.model.v23.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 *<p>Represents an HL7 OM1 message segment (General - fields that apply to most observations). 049 * This segment has the following fields:</p> 050 * <ul> 051 * <li>OM1-1: Sequence Number - Test/ Observation Master File (NM) <b>optional </b> 052 * <li>OM1-2: Producer's Test/Observation ID (CE) <b> </b> 053 * <li>OM1-3: Permitted Data Types (ID) <b>optional repeating</b> 054 * <li>OM1-4: Specimen Required (ID) <b> </b> 055 * <li>OM1-5: Producer ID (CE) <b> </b> 056 * <li>OM1-6: Observation Description (CE) <b>optional </b> 057 * <li>OM1-7: Other Test/Observation IDs for the Observation (CE) <b>optional </b> 058 * <li>OM1-8: Other Names (ST) <b> repeating</b> 059 * <li>OM1-9: Preferred Report Name for the Observation (ST) <b>optional </b> 060 * <li>OM1-10: Preferred Short Name or Mnemonic for Observation (ST) <b>optional </b> 061 * <li>OM1-11: Preferred Long Name for the Observation (ST) <b>optional </b> 062 * <li>OM1-12: Orderability (ID) <b>optional </b> 063 * <li>OM1-13: Identity of Instrument Used to Perfrom this Study (CE) <b>optional repeating</b> 064 * <li>OM1-14: Coded Representation of Method (CE) <b>optional </b> 065 * <li>OM1-15: Portable (ID) <b>optional </b> 066 * <li>OM1-16: Observation Producing Department/Section (CE) <b>optional repeating</b> 067 * <li>OM1-17: Telephone Number of Section (TN) <b>optional </b> 068 * <li>OM1-18: Nature of Test/Observation (ID) <b>optional </b> 069 * <li>OM1-19: Report Subheader (CE) <b>optional </b> 070 * <li>OM1-20: Report Display Order (ST) <b>optional </b> 071 * <li>OM1-21: Date/Time Stamp for any change in Def Attri for Obs (TS) <b>optional </b> 072 * <li>OM1-22: Effective Date/Time of Change in Test Proc. that make Results Non-Comparable (TS) <b>optional </b> 073 * <li>OM1-23: Typical Turn-Around Time (NM) <b>optional </b> 074 * <li>OM1-24: Processing Time (NM) <b>optional </b> 075 * <li>OM1-25: Processing Priority (ID) <b>optional repeating</b> 076 * <li>OM1-26: Reporting Priority (ID) <b>optional </b> 077 * <li>OM1-27: Outside Site(s) Where Observation may be Performed (CE) <b>optional repeating</b> 078 * <li>OM1-28: Address of Outside Site(s) (AD) <b>optional </b> 079 * <li>OM1-29: Phone Number of Outside Site (TN) <b>optional </b> 080 * <li>OM1-30: Confidentiality Code (ID) <b>optional </b> 081 * <li>OM1-31: Observations Required to Interpret the Observation (CE) <b>optional </b> 082 * <li>OM1-32: Interpretation of Observations (TX) <b>optional </b> 083 * <li>OM1-33: Contraindications to Observations (CE) <b>optional </b> 084 * <li>OM1-34: Reflex Tests/Observations (CE) <b>optional repeating</b> 085 * <li>OM1-35: Rules that Trigger Reflex Testing (ST) <b>optional </b> 086 * <li>OM1-36: Fixed Canned Message (CE) <b>optional </b> 087 * <li>OM1-37: Patient Preparation (TX) <b>optional </b> 088 * <li>OM1-38: Procedure Medication (CE) <b>optional </b> 089 * <li>OM1-39: Factors that may Effect the Observation (TX) <b>optional </b> 090 * <li>OM1-40: Test/Observation Performance Schedule (ST) <b>optional repeating</b> 091 * <li>OM1-41: Description of Test Methods (TX) <b>optional </b> 092 * <li>OM1-42: Kind of Quantity Observed (CE) <b>optional </b> 093 * <li>OM1-43: Point versus Interval (CE) <b>optional </b> 094 * <li>OM1-44: Challenge information (TX) <b>optional </b> 095 * <li>OM1-45: Relationship modifier (CE) <b>optional </b> 096 * <li>OM1-46: Target anatomic site of test (CE) <b>optional </b> 097 * <li>OM1-47: Modality of imaging measurement (CE) <b>optional </b> 098 * </ul> 099 */ 100@SuppressWarnings("unused") 101public class OM1 extends AbstractSegment { 102 103 /** 104 * Creates a new OM1 segment 105 */ 106 public OM1(Group parent, ModelClassFactory factory) { 107 super(parent, factory); 108 init(factory); 109 } 110 111 private void init(ModelClassFactory factory) { 112 try { 113 this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Sequence Number - Test/ Observation Master File"); 114 this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer's Test/Observation ID"); 115 this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(125) }, "Permitted Data Types"); 116 this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Specimen Required"); 117 this.add(CE.class, true, 1, 200, new Object[]{ getMessage() }, "Producer ID"); 118 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Observation Description"); 119 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Other Test/Observation IDs for the Observation"); 120 this.add(ST.class, true, 0, 200, new Object[]{ getMessage() }, "Other Names"); 121 this.add(ST.class, false, 1, 30, new Object[]{ getMessage() }, "Preferred Report Name for the Observation"); 122 this.add(ST.class, false, 1, 8, new Object[]{ getMessage() }, "Preferred Short Name or Mnemonic for Observation"); 123 this.add(ST.class, false, 1, 200, new Object[]{ getMessage() }, "Preferred Long Name for the Observation"); 124 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Orderability"); 125 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Identity of Instrument Used to Perfrom this Study"); 126 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Coded Representation of Method"); 127 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Portable"); 128 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Observation Producing Department/Section"); 129 this.add(TN.class, false, 1, 40, new Object[]{ getMessage() }, "Telephone Number of Section"); 130 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(174) }, "Nature of Test/Observation"); 131 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Report Subheader"); 132 this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Report Display Order"); 133 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time Stamp for any change in Def Attri for Obs"); 134 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable"); 135 this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Typical Turn-Around Time"); 136 this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Processing Time"); 137 this.add(ID.class, false, 0, 40, new Object[]{ getMessage(), new Integer(168) }, "Processing Priority"); 138 this.add(ID.class, false, 1, 5, new Object[]{ getMessage(), new Integer(169) }, "Reporting Priority"); 139 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Outside Site(s) Where Observation may be Performed"); 140 this.add(AD.class, false, 1, 1000, new Object[]{ getMessage() }, "Address of Outside Site(s)"); 141 this.add(TN.class, false, 1, 400, new Object[]{ getMessage() }, "Phone Number of Outside Site"); 142 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(177) }, "Confidentiality Code"); 143 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Observations Required to Interpret the Observation"); 144 this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Interpretation of Observations"); 145 this.add(CE.class, false, 1, 65536, new Object[]{ getMessage() }, "Contraindications to Observations"); 146 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Reflex Tests/Observations"); 147 this.add(ST.class, false, 1, 80, new Object[]{ getMessage() }, "Rules that Trigger Reflex Testing"); 148 this.add(CE.class, false, 1, 65536, new Object[]{ getMessage() }, "Fixed Canned Message"); 149 this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Patient Preparation"); 150 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Procedure Medication"); 151 this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Factors that may Effect the Observation"); 152 this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Test/Observation Performance Schedule"); 153 this.add(TX.class, false, 1, 65536, new Object[]{ getMessage() }, "Description of Test Methods"); 154 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Kind of Quantity Observed"); 155 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Point versus Interval"); 156 this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Challenge information"); 157 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Relationship modifier"); 158 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Target anatomic site of test"); 159 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Modality of imaging measurement"); 160 } catch(HL7Exception e) { 161 log.error("Unexpected error creating OM1 - this is probably a bug in the source code generator.", e); 162 } 163 } 164 165 166 167 /** 168 * Returns 169 * OM1-1: "Sequence Number - Test/ Observation Master File" - creates it if necessary 170 */ 171 public NM getSequenceNumberTestObservationMasterFile() { 172 NM retVal = this.getTypedField(1, 0); 173 return retVal; 174 } 175 176 /** 177 * Returns 178 * OM1-1: "Sequence Number - Test/ Observation Master File" - creates it if necessary 179 */ 180 public NM getOm11_SequenceNumberTestObservationMasterFile() { 181 NM retVal = this.getTypedField(1, 0); 182 return retVal; 183 } 184 185 186 187 /** 188 * Returns 189 * OM1-2: "Producer's Test/Observation ID" - creates it if necessary 190 */ 191 public CE getProducerSTestObservationID() { 192 CE retVal = this.getTypedField(2, 0); 193 return retVal; 194 } 195 196 /** 197 * Returns 198 * OM1-2: "Producer's Test/Observation ID" - creates it if necessary 199 */ 200 public CE getOm12_ProducerSTestObservationID() { 201 CE retVal = this.getTypedField(2, 0); 202 return retVal; 203 } 204 205 206 /** 207 * Returns all repetitions of Permitted Data Types (OM1-3). 208 */ 209 public ID[] getPermittedDataTypes() { 210 ID[] retVal = this.getTypedField(3, new ID[0]); 211 return retVal; 212 } 213 214 215 /** 216 * Returns all repetitions of Permitted Data Types (OM1-3). 217 */ 218 public ID[] getOm13_PermittedDataTypes() { 219 ID[] retVal = this.getTypedField(3, new ID[0]); 220 return retVal; 221 } 222 223 224 /** 225 * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3). 226 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 227 * it will return zero. 228 */ 229 public int getPermittedDataTypesReps() { 230 return this.getReps(3); 231 } 232 233 234 /** 235 * Returns a specific repetition of 236 * OM1-3: "Permitted Data Types" - creates it if necessary 237 * 238 * @param rep The repetition index (0-indexed) 239 */ 240 public ID getPermittedDataTypes(int rep) { 241 ID retVal = this.getTypedField(3, rep); 242 return retVal; 243 } 244 245 /** 246 * Returns a specific repetition of 247 * OM1-3: "Permitted Data Types" - creates it if necessary 248 * 249 * @param rep The repetition index (0-indexed) 250 */ 251 public ID getOm13_PermittedDataTypes(int rep) { 252 ID retVal = this.getTypedField(3, rep); 253 return retVal; 254 } 255 256 /** 257 * Returns a count of the current number of repetitions of Permitted Data Types (OM1-3). 258 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 259 * it will return zero. 260 */ 261 public int getOm13_PermittedDataTypesReps() { 262 return this.getReps(3); 263 } 264 265 266 /** 267 * Inserts a repetition of 268 * OM1-3: "Permitted Data Types" at a specific index 269 * 270 * @param rep The repetition index (0-indexed) 271 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 272 */ 273 public ID insertPermittedDataTypes(int rep) throws HL7Exception { 274 return (ID) super.insertRepetition(3, rep); 275 } 276 277 278 /** 279 * Inserts a repetition of 280 * OM1-3: "Permitted Data Types" at a specific index 281 * 282 * @param rep The repetition index (0-indexed) 283 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 284 */ 285 public ID insertOm13_PermittedDataTypes(int rep) throws HL7Exception { 286 return (ID) super.insertRepetition(3, rep); 287 } 288 289 290 /** 291 * Removes a repetition of 292 * OM1-3: "Permitted Data Types" at a specific index 293 * 294 * @param rep The repetition index (0-indexed) 295 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 296 */ 297 public ID removePermittedDataTypes(int rep) throws HL7Exception { 298 return (ID) super.removeRepetition(3, rep); 299 } 300 301 302 /** 303 * Removes a repetition of 304 * OM1-3: "Permitted Data Types" at a specific index 305 * 306 * @param rep The repetition index (0-indexed) 307 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 308 */ 309 public ID removeOm13_PermittedDataTypes(int rep) throws HL7Exception { 310 return (ID) super.removeRepetition(3, rep); 311 } 312 313 314 315 316 /** 317 * Returns 318 * OM1-4: "Specimen Required" - creates it if necessary 319 */ 320 public ID getSpecimenRequired() { 321 ID retVal = this.getTypedField(4, 0); 322 return retVal; 323 } 324 325 /** 326 * Returns 327 * OM1-4: "Specimen Required" - creates it if necessary 328 */ 329 public ID getOm14_SpecimenRequired() { 330 ID retVal = this.getTypedField(4, 0); 331 return retVal; 332 } 333 334 335 336 /** 337 * Returns 338 * OM1-5: "Producer ID" - creates it if necessary 339 */ 340 public CE getProducerID() { 341 CE retVal = this.getTypedField(5, 0); 342 return retVal; 343 } 344 345 /** 346 * Returns 347 * OM1-5: "Producer ID" - creates it if necessary 348 */ 349 public CE getOm15_ProducerID() { 350 CE retVal = this.getTypedField(5, 0); 351 return retVal; 352 } 353 354 355 356 /** 357 * Returns 358 * OM1-6: "Observation Description" - creates it if necessary 359 */ 360 public CE getObservationDescription() { 361 CE retVal = this.getTypedField(6, 0); 362 return retVal; 363 } 364 365 /** 366 * Returns 367 * OM1-6: "Observation Description" - creates it if necessary 368 */ 369 public CE getOm16_ObservationDescription() { 370 CE retVal = this.getTypedField(6, 0); 371 return retVal; 372 } 373 374 375 376 /** 377 * Returns 378 * OM1-7: "Other Test/Observation IDs for the Observation" - creates it if necessary 379 */ 380 public CE getOtherTestObservationIDsForTheObservation() { 381 CE retVal = this.getTypedField(7, 0); 382 return retVal; 383 } 384 385 /** 386 * Returns 387 * OM1-7: "Other Test/Observation IDs for the Observation" - creates it if necessary 388 */ 389 public CE getOm17_OtherTestObservationIDsForTheObservation() { 390 CE retVal = this.getTypedField(7, 0); 391 return retVal; 392 } 393 394 395 /** 396 * Returns all repetitions of Other Names (OM1-8). 397 */ 398 public ST[] getOtherNames() { 399 ST[] retVal = this.getTypedField(8, new ST[0]); 400 return retVal; 401 } 402 403 404 /** 405 * Returns all repetitions of Other Names (OM1-8). 406 */ 407 public ST[] getOm18_OtherNames() { 408 ST[] retVal = this.getTypedField(8, new ST[0]); 409 return retVal; 410 } 411 412 413 /** 414 * Returns a count of the current number of repetitions of Other Names (OM1-8). 415 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 416 * it will return zero. 417 */ 418 public int getOtherNamesReps() { 419 return this.getReps(8); 420 } 421 422 423 /** 424 * Returns a specific repetition of 425 * OM1-8: "Other Names" - creates it if necessary 426 * 427 * @param rep The repetition index (0-indexed) 428 */ 429 public ST getOtherNames(int rep) { 430 ST retVal = this.getTypedField(8, rep); 431 return retVal; 432 } 433 434 /** 435 * Returns a specific repetition of 436 * OM1-8: "Other Names" - creates it if necessary 437 * 438 * @param rep The repetition index (0-indexed) 439 */ 440 public ST getOm18_OtherNames(int rep) { 441 ST retVal = this.getTypedField(8, rep); 442 return retVal; 443 } 444 445 /** 446 * Returns a count of the current number of repetitions of Other Names (OM1-8). 447 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 448 * it will return zero. 449 */ 450 public int getOm18_OtherNamesReps() { 451 return this.getReps(8); 452 } 453 454 455 /** 456 * Inserts a repetition of 457 * OM1-8: "Other Names" at a specific index 458 * 459 * @param rep The repetition index (0-indexed) 460 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 461 */ 462 public ST insertOtherNames(int rep) throws HL7Exception { 463 return (ST) super.insertRepetition(8, rep); 464 } 465 466 467 /** 468 * Inserts a repetition of 469 * OM1-8: "Other Names" at a specific index 470 * 471 * @param rep The repetition index (0-indexed) 472 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 473 */ 474 public ST insertOm18_OtherNames(int rep) throws HL7Exception { 475 return (ST) super.insertRepetition(8, rep); 476 } 477 478 479 /** 480 * Removes a repetition of 481 * OM1-8: "Other Names" at a specific index 482 * 483 * @param rep The repetition index (0-indexed) 484 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 485 */ 486 public ST removeOtherNames(int rep) throws HL7Exception { 487 return (ST) super.removeRepetition(8, rep); 488 } 489 490 491 /** 492 * Removes a repetition of 493 * OM1-8: "Other Names" at a specific index 494 * 495 * @param rep The repetition index (0-indexed) 496 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 497 */ 498 public ST removeOm18_OtherNames(int rep) throws HL7Exception { 499 return (ST) super.removeRepetition(8, rep); 500 } 501 502 503 504 505 /** 506 * Returns 507 * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary 508 */ 509 public ST getPreferredReportNameForTheObservation() { 510 ST retVal = this.getTypedField(9, 0); 511 return retVal; 512 } 513 514 /** 515 * Returns 516 * OM1-9: "Preferred Report Name for the Observation" - creates it if necessary 517 */ 518 public ST getOm19_PreferredReportNameForTheObservation() { 519 ST retVal = this.getTypedField(9, 0); 520 return retVal; 521 } 522 523 524 525 /** 526 * Returns 527 * OM1-10: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary 528 */ 529 public ST getPreferredShortNameOrMnemonicForObservation() { 530 ST retVal = this.getTypedField(10, 0); 531 return retVal; 532 } 533 534 /** 535 * Returns 536 * OM1-10: "Preferred Short Name or Mnemonic for Observation" - creates it if necessary 537 */ 538 public ST getOm110_PreferredShortNameOrMnemonicForObservation() { 539 ST retVal = this.getTypedField(10, 0); 540 return retVal; 541 } 542 543 544 545 /** 546 * Returns 547 * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary 548 */ 549 public ST getPreferredLongNameForTheObservation() { 550 ST retVal = this.getTypedField(11, 0); 551 return retVal; 552 } 553 554 /** 555 * Returns 556 * OM1-11: "Preferred Long Name for the Observation" - creates it if necessary 557 */ 558 public ST getOm111_PreferredLongNameForTheObservation() { 559 ST retVal = this.getTypedField(11, 0); 560 return retVal; 561 } 562 563 564 565 /** 566 * Returns 567 * OM1-12: "Orderability" - creates it if necessary 568 */ 569 public ID getOrderability() { 570 ID retVal = this.getTypedField(12, 0); 571 return retVal; 572 } 573 574 /** 575 * Returns 576 * OM1-12: "Orderability" - creates it if necessary 577 */ 578 public ID getOm112_Orderability() { 579 ID retVal = this.getTypedField(12, 0); 580 return retVal; 581 } 582 583 584 /** 585 * Returns all repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13). 586 */ 587 public CE[] getIdentityOfInstrumentUsedToPerfromThisStudy() { 588 CE[] retVal = this.getTypedField(13, new CE[0]); 589 return retVal; 590 } 591 592 593 /** 594 * Returns all repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13). 595 */ 596 public CE[] getOm113_IdentityOfInstrumentUsedToPerfromThisStudy() { 597 CE[] retVal = this.getTypedField(13, new CE[0]); 598 return retVal; 599 } 600 601 602 /** 603 * Returns a count of the current number of repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13). 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 getIdentityOfInstrumentUsedToPerfromThisStudyReps() { 608 return this.getReps(13); 609 } 610 611 612 /** 613 * Returns a specific repetition of 614 * OM1-13: "Identity of Instrument Used to Perfrom this Study" - creates it if necessary 615 * 616 * @param rep The repetition index (0-indexed) 617 */ 618 public CE getIdentityOfInstrumentUsedToPerfromThisStudy(int rep) { 619 CE retVal = this.getTypedField(13, rep); 620 return retVal; 621 } 622 623 /** 624 * Returns a specific repetition of 625 * OM1-13: "Identity of Instrument Used to Perfrom this Study" - creates it if necessary 626 * 627 * @param rep The repetition index (0-indexed) 628 */ 629 public CE getOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) { 630 CE retVal = this.getTypedField(13, rep); 631 return retVal; 632 } 633 634 /** 635 * Returns a count of the current number of repetitions of Identity of Instrument Used to Perfrom this Study (OM1-13). 636 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 637 * it will return zero. 638 */ 639 public int getOm113_IdentityOfInstrumentUsedToPerfromThisStudyReps() { 640 return this.getReps(13); 641 } 642 643 644 /** 645 * Inserts a repetition of 646 * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index 647 * 648 * @param rep The repetition index (0-indexed) 649 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 650 */ 651 public CE insertIdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 652 return (CE) super.insertRepetition(13, rep); 653 } 654 655 656 /** 657 * Inserts a repetition of 658 * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index 659 * 660 * @param rep The repetition index (0-indexed) 661 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 662 */ 663 public CE insertOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 664 return (CE) super.insertRepetition(13, rep); 665 } 666 667 668 /** 669 * Removes a repetition of 670 * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index 671 * 672 * @param rep The repetition index (0-indexed) 673 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 674 */ 675 public CE removeIdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 676 return (CE) super.removeRepetition(13, rep); 677 } 678 679 680 /** 681 * Removes a repetition of 682 * OM1-13: "Identity of Instrument Used to Perfrom this Study" at a specific index 683 * 684 * @param rep The repetition index (0-indexed) 685 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 686 */ 687 public CE removeOm113_IdentityOfInstrumentUsedToPerfromThisStudy(int rep) throws HL7Exception { 688 return (CE) super.removeRepetition(13, rep); 689 } 690 691 692 693 694 /** 695 * Returns 696 * OM1-14: "Coded Representation of Method" - creates it if necessary 697 */ 698 public CE getCodedRepresentationOfMethod() { 699 CE retVal = this.getTypedField(14, 0); 700 return retVal; 701 } 702 703 /** 704 * Returns 705 * OM1-14: "Coded Representation of Method" - creates it if necessary 706 */ 707 public CE getOm114_CodedRepresentationOfMethod() { 708 CE retVal = this.getTypedField(14, 0); 709 return retVal; 710 } 711 712 713 714 /** 715 * Returns 716 * OM1-15: "Portable" - creates it if necessary 717 */ 718 public ID getPortable() { 719 ID retVal = this.getTypedField(15, 0); 720 return retVal; 721 } 722 723 /** 724 * Returns 725 * OM1-15: "Portable" - creates it if necessary 726 */ 727 public ID getOm115_Portable() { 728 ID retVal = this.getTypedField(15, 0); 729 return retVal; 730 } 731 732 733 /** 734 * Returns all repetitions of Observation Producing Department/Section (OM1-16). 735 */ 736 public CE[] getObservationProducingDepartmentSection() { 737 CE[] retVal = this.getTypedField(16, new CE[0]); 738 return retVal; 739 } 740 741 742 /** 743 * Returns all repetitions of Observation Producing Department/Section (OM1-16). 744 */ 745 public CE[] getOm116_ObservationProducingDepartmentSection() { 746 CE[] retVal = this.getTypedField(16, new CE[0]); 747 return retVal; 748 } 749 750 751 /** 752 * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16). 753 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 754 * it will return zero. 755 */ 756 public int getObservationProducingDepartmentSectionReps() { 757 return this.getReps(16); 758 } 759 760 761 /** 762 * Returns a specific repetition of 763 * OM1-16: "Observation Producing Department/Section" - creates it if necessary 764 * 765 * @param rep The repetition index (0-indexed) 766 */ 767 public CE getObservationProducingDepartmentSection(int rep) { 768 CE retVal = this.getTypedField(16, rep); 769 return retVal; 770 } 771 772 /** 773 * Returns a specific repetition of 774 * OM1-16: "Observation Producing Department/Section" - creates it if necessary 775 * 776 * @param rep The repetition index (0-indexed) 777 */ 778 public CE getOm116_ObservationProducingDepartmentSection(int rep) { 779 CE retVal = this.getTypedField(16, rep); 780 return retVal; 781 } 782 783 /** 784 * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16). 785 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 786 * it will return zero. 787 */ 788 public int getOm116_ObservationProducingDepartmentSectionReps() { 789 return this.getReps(16); 790 } 791 792 793 /** 794 * Inserts a repetition of 795 * OM1-16: "Observation Producing Department/Section" at a specific index 796 * 797 * @param rep The repetition index (0-indexed) 798 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 799 */ 800 public CE insertObservationProducingDepartmentSection(int rep) throws HL7Exception { 801 return (CE) super.insertRepetition(16, rep); 802 } 803 804 805 /** 806 * Inserts a repetition of 807 * OM1-16: "Observation Producing Department/Section" at a specific index 808 * 809 * @param rep The repetition index (0-indexed) 810 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 811 */ 812 public CE insertOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 813 return (CE) super.insertRepetition(16, rep); 814 } 815 816 817 /** 818 * Removes a repetition of 819 * OM1-16: "Observation Producing Department/Section" at a specific index 820 * 821 * @param rep The repetition index (0-indexed) 822 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 823 */ 824 public CE removeObservationProducingDepartmentSection(int rep) throws HL7Exception { 825 return (CE) super.removeRepetition(16, rep); 826 } 827 828 829 /** 830 * Removes a repetition of 831 * OM1-16: "Observation Producing Department/Section" at a specific index 832 * 833 * @param rep The repetition index (0-indexed) 834 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 835 */ 836 public CE removeOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 837 return (CE) super.removeRepetition(16, rep); 838 } 839 840 841 842 843 /** 844 * Returns 845 * OM1-17: "Telephone Number of Section" - creates it if necessary 846 */ 847 public TN getTelephoneNumberOfSection() { 848 TN retVal = this.getTypedField(17, 0); 849 return retVal; 850 } 851 852 /** 853 * Returns 854 * OM1-17: "Telephone Number of Section" - creates it if necessary 855 */ 856 public TN getOm117_TelephoneNumberOfSection() { 857 TN retVal = this.getTypedField(17, 0); 858 return retVal; 859 } 860 861 862 863 /** 864 * Returns 865 * OM1-18: "Nature of Test/Observation" - creates it if necessary 866 */ 867 public ID getNatureOfTestObservation() { 868 ID retVal = this.getTypedField(18, 0); 869 return retVal; 870 } 871 872 /** 873 * Returns 874 * OM1-18: "Nature of Test/Observation" - creates it if necessary 875 */ 876 public ID getOm118_NatureOfTestObservation() { 877 ID retVal = this.getTypedField(18, 0); 878 return retVal; 879 } 880 881 882 883 /** 884 * Returns 885 * OM1-19: "Report Subheader" - creates it if necessary 886 */ 887 public CE getReportSubheader() { 888 CE retVal = this.getTypedField(19, 0); 889 return retVal; 890 } 891 892 /** 893 * Returns 894 * OM1-19: "Report Subheader" - creates it if necessary 895 */ 896 public CE getOm119_ReportSubheader() { 897 CE retVal = this.getTypedField(19, 0); 898 return retVal; 899 } 900 901 902 903 /** 904 * Returns 905 * OM1-20: "Report Display Order" - creates it if necessary 906 */ 907 public ST getReportDisplayOrder() { 908 ST retVal = this.getTypedField(20, 0); 909 return retVal; 910 } 911 912 /** 913 * Returns 914 * OM1-20: "Report Display Order" - creates it if necessary 915 */ 916 public ST getOm120_ReportDisplayOrder() { 917 ST retVal = this.getTypedField(20, 0); 918 return retVal; 919 } 920 921 922 923 /** 924 * Returns 925 * OM1-21: "Date/Time Stamp for any change in Def Attri for Obs" - creates it if necessary 926 */ 927 public TS getDateTimeStampForAnyChangeInDefAttriForObs() { 928 TS retVal = this.getTypedField(21, 0); 929 return retVal; 930 } 931 932 /** 933 * Returns 934 * OM1-21: "Date/Time Stamp for any change in Def Attri for Obs" - creates it if necessary 935 */ 936 public TS getOm121_DateTimeStampForAnyChangeInDefAttriForObs() { 937 TS retVal = this.getTypedField(21, 0); 938 return retVal; 939 } 940 941 942 943 /** 944 * Returns 945 * OM1-22: "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable" - creates it if necessary 946 */ 947 public TS getEffectiveDateTimeOfChangeInTestProcThatMakeResultsNonComparable() { 948 TS retVal = this.getTypedField(22, 0); 949 return retVal; 950 } 951 952 /** 953 * Returns 954 * OM1-22: "Effective Date/Time of Change in Test Proc. that make Results Non-Comparable" - creates it if necessary 955 */ 956 public TS getOm122_EffectiveDateTimeOfChangeInTestProcThatMakeResultsNonComparable() { 957 TS retVal = this.getTypedField(22, 0); 958 return retVal; 959 } 960 961 962 963 /** 964 * Returns 965 * OM1-23: "Typical Turn-Around Time" - creates it if necessary 966 */ 967 public NM getTypicalTurnAroundTime() { 968 NM retVal = this.getTypedField(23, 0); 969 return retVal; 970 } 971 972 /** 973 * Returns 974 * OM1-23: "Typical Turn-Around Time" - creates it if necessary 975 */ 976 public NM getOm123_TypicalTurnAroundTime() { 977 NM retVal = this.getTypedField(23, 0); 978 return retVal; 979 } 980 981 982 983 /** 984 * Returns 985 * OM1-24: "Processing Time" - creates it if necessary 986 */ 987 public NM getProcessingTime() { 988 NM retVal = this.getTypedField(24, 0); 989 return retVal; 990 } 991 992 /** 993 * Returns 994 * OM1-24: "Processing Time" - creates it if necessary 995 */ 996 public NM getOm124_ProcessingTime() { 997 NM retVal = this.getTypedField(24, 0); 998 return retVal; 999 } 1000 1001 1002 /** 1003 * Returns all repetitions of Processing Priority (OM1-25). 1004 */ 1005 public ID[] getProcessingPriority() { 1006 ID[] retVal = this.getTypedField(25, new ID[0]); 1007 return retVal; 1008 } 1009 1010 1011 /** 1012 * Returns all repetitions of Processing Priority (OM1-25). 1013 */ 1014 public ID[] getOm125_ProcessingPriority() { 1015 ID[] retVal = this.getTypedField(25, new ID[0]); 1016 return retVal; 1017 } 1018 1019 1020 /** 1021 * Returns a count of the current number of repetitions of Processing Priority (OM1-25). 1022 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1023 * it will return zero. 1024 */ 1025 public int getProcessingPriorityReps() { 1026 return this.getReps(25); 1027 } 1028 1029 1030 /** 1031 * Returns a specific repetition of 1032 * OM1-25: "Processing Priority" - creates it if necessary 1033 * 1034 * @param rep The repetition index (0-indexed) 1035 */ 1036 public ID getProcessingPriority(int rep) { 1037 ID retVal = this.getTypedField(25, rep); 1038 return retVal; 1039 } 1040 1041 /** 1042 * Returns a specific repetition of 1043 * OM1-25: "Processing Priority" - creates it if necessary 1044 * 1045 * @param rep The repetition index (0-indexed) 1046 */ 1047 public ID getOm125_ProcessingPriority(int rep) { 1048 ID retVal = this.getTypedField(25, rep); 1049 return retVal; 1050 } 1051 1052 /** 1053 * Returns a count of the current number of repetitions of Processing Priority (OM1-25). 1054 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1055 * it will return zero. 1056 */ 1057 public int getOm125_ProcessingPriorityReps() { 1058 return this.getReps(25); 1059 } 1060 1061 1062 /** 1063 * Inserts a repetition of 1064 * OM1-25: "Processing Priority" at a specific index 1065 * 1066 * @param rep The repetition index (0-indexed) 1067 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1068 */ 1069 public ID insertProcessingPriority(int rep) throws HL7Exception { 1070 return (ID) super.insertRepetition(25, rep); 1071 } 1072 1073 1074 /** 1075 * Inserts a repetition of 1076 * OM1-25: "Processing Priority" at a specific index 1077 * 1078 * @param rep The repetition index (0-indexed) 1079 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1080 */ 1081 public ID insertOm125_ProcessingPriority(int rep) throws HL7Exception { 1082 return (ID) super.insertRepetition(25, rep); 1083 } 1084 1085 1086 /** 1087 * Removes a repetition of 1088 * OM1-25: "Processing Priority" at a specific index 1089 * 1090 * @param rep The repetition index (0-indexed) 1091 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1092 */ 1093 public ID removeProcessingPriority(int rep) throws HL7Exception { 1094 return (ID) super.removeRepetition(25, rep); 1095 } 1096 1097 1098 /** 1099 * Removes a repetition of 1100 * OM1-25: "Processing Priority" at a specific index 1101 * 1102 * @param rep The repetition index (0-indexed) 1103 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1104 */ 1105 public ID removeOm125_ProcessingPriority(int rep) throws HL7Exception { 1106 return (ID) super.removeRepetition(25, rep); 1107 } 1108 1109 1110 1111 1112 /** 1113 * Returns 1114 * OM1-26: "Reporting Priority" - creates it if necessary 1115 */ 1116 public ID getReportingPriority() { 1117 ID retVal = this.getTypedField(26, 0); 1118 return retVal; 1119 } 1120 1121 /** 1122 * Returns 1123 * OM1-26: "Reporting Priority" - creates it if necessary 1124 */ 1125 public ID getOm126_ReportingPriority() { 1126 ID retVal = this.getTypedField(26, 0); 1127 return retVal; 1128 } 1129 1130 1131 /** 1132 * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1133 */ 1134 public CE[] getOutsideSiteSWhereObservationMayBePerformed() { 1135 CE[] retVal = this.getTypedField(27, new CE[0]); 1136 return retVal; 1137 } 1138 1139 1140 /** 1141 * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1142 */ 1143 public CE[] getOm127_OutsideSiteSWhereObservationMayBePerformed() { 1144 CE[] retVal = this.getTypedField(27, new CE[0]); 1145 return retVal; 1146 } 1147 1148 1149 /** 1150 * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1151 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1152 * it will return zero. 1153 */ 1154 public int getOutsideSiteSWhereObservationMayBePerformedReps() { 1155 return this.getReps(27); 1156 } 1157 1158 1159 /** 1160 * Returns a specific repetition of 1161 * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary 1162 * 1163 * @param rep The repetition index (0-indexed) 1164 */ 1165 public CE getOutsideSiteSWhereObservationMayBePerformed(int rep) { 1166 CE retVal = this.getTypedField(27, rep); 1167 return retVal; 1168 } 1169 1170 /** 1171 * Returns a specific repetition of 1172 * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary 1173 * 1174 * @param rep The repetition index (0-indexed) 1175 */ 1176 public CE getOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) { 1177 CE retVal = this.getTypedField(27, rep); 1178 return retVal; 1179 } 1180 1181 /** 1182 * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1183 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1184 * it will return zero. 1185 */ 1186 public int getOm127_OutsideSiteSWhereObservationMayBePerformedReps() { 1187 return this.getReps(27); 1188 } 1189 1190 1191 /** 1192 * Inserts a repetition of 1193 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1194 * 1195 * @param rep The repetition index (0-indexed) 1196 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1197 */ 1198 public CE insertOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1199 return (CE) super.insertRepetition(27, rep); 1200 } 1201 1202 1203 /** 1204 * Inserts a repetition of 1205 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1206 * 1207 * @param rep The repetition index (0-indexed) 1208 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1209 */ 1210 public CE insertOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1211 return (CE) super.insertRepetition(27, rep); 1212 } 1213 1214 1215 /** 1216 * Removes a repetition of 1217 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1218 * 1219 * @param rep The repetition index (0-indexed) 1220 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1221 */ 1222 public CE removeOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1223 return (CE) super.removeRepetition(27, rep); 1224 } 1225 1226 1227 /** 1228 * Removes a repetition of 1229 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1230 * 1231 * @param rep The repetition index (0-indexed) 1232 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1233 */ 1234 public CE removeOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1235 return (CE) super.removeRepetition(27, rep); 1236 } 1237 1238 1239 1240 1241 /** 1242 * Returns 1243 * OM1-28: "Address of Outside Site(s)" - creates it if necessary 1244 */ 1245 public AD getAddressOfOutsideSiteS() { 1246 AD retVal = this.getTypedField(28, 0); 1247 return retVal; 1248 } 1249 1250 /** 1251 * Returns 1252 * OM1-28: "Address of Outside Site(s)" - creates it if necessary 1253 */ 1254 public AD getOm128_AddressOfOutsideSiteS() { 1255 AD retVal = this.getTypedField(28, 0); 1256 return retVal; 1257 } 1258 1259 1260 1261 /** 1262 * Returns 1263 * OM1-29: "Phone Number of Outside Site" - creates it if necessary 1264 */ 1265 public TN getPhoneNumberOfOutsideSite() { 1266 TN retVal = this.getTypedField(29, 0); 1267 return retVal; 1268 } 1269 1270 /** 1271 * Returns 1272 * OM1-29: "Phone Number of Outside Site" - creates it if necessary 1273 */ 1274 public TN getOm129_PhoneNumberOfOutsideSite() { 1275 TN retVal = this.getTypedField(29, 0); 1276 return retVal; 1277 } 1278 1279 1280 1281 /** 1282 * Returns 1283 * OM1-30: "Confidentiality Code" - creates it if necessary 1284 */ 1285 public ID getConfidentialityCode() { 1286 ID retVal = this.getTypedField(30, 0); 1287 return retVal; 1288 } 1289 1290 /** 1291 * Returns 1292 * OM1-30: "Confidentiality Code" - creates it if necessary 1293 */ 1294 public ID getOm130_ConfidentialityCode() { 1295 ID retVal = this.getTypedField(30, 0); 1296 return retVal; 1297 } 1298 1299 1300 1301 /** 1302 * Returns 1303 * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary 1304 */ 1305 public CE getObservationsRequiredToInterpretTheObservation() { 1306 CE retVal = this.getTypedField(31, 0); 1307 return retVal; 1308 } 1309 1310 /** 1311 * Returns 1312 * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary 1313 */ 1314 public CE getOm131_ObservationsRequiredToInterpretTheObservation() { 1315 CE retVal = this.getTypedField(31, 0); 1316 return retVal; 1317 } 1318 1319 1320 1321 /** 1322 * Returns 1323 * OM1-32: "Interpretation of Observations" - creates it if necessary 1324 */ 1325 public TX getInterpretationOfObservations() { 1326 TX retVal = this.getTypedField(32, 0); 1327 return retVal; 1328 } 1329 1330 /** 1331 * Returns 1332 * OM1-32: "Interpretation of Observations" - creates it if necessary 1333 */ 1334 public TX getOm132_InterpretationOfObservations() { 1335 TX retVal = this.getTypedField(32, 0); 1336 return retVal; 1337 } 1338 1339 1340 1341 /** 1342 * Returns 1343 * OM1-33: "Contraindications to Observations" - creates it if necessary 1344 */ 1345 public CE getContraindicationsToObservations() { 1346 CE retVal = this.getTypedField(33, 0); 1347 return retVal; 1348 } 1349 1350 /** 1351 * Returns 1352 * OM1-33: "Contraindications to Observations" - creates it if necessary 1353 */ 1354 public CE getOm133_ContraindicationsToObservations() { 1355 CE retVal = this.getTypedField(33, 0); 1356 return retVal; 1357 } 1358 1359 1360 /** 1361 * Returns all repetitions of Reflex Tests/Observations (OM1-34). 1362 */ 1363 public CE[] getReflexTestsObservations() { 1364 CE[] retVal = this.getTypedField(34, new CE[0]); 1365 return retVal; 1366 } 1367 1368 1369 /** 1370 * Returns all repetitions of Reflex Tests/Observations (OM1-34). 1371 */ 1372 public CE[] getOm134_ReflexTestsObservations() { 1373 CE[] retVal = this.getTypedField(34, new CE[0]); 1374 return retVal; 1375 } 1376 1377 1378 /** 1379 * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34). 1380 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1381 * it will return zero. 1382 */ 1383 public int getReflexTestsObservationsReps() { 1384 return this.getReps(34); 1385 } 1386 1387 1388 /** 1389 * Returns a specific repetition of 1390 * OM1-34: "Reflex Tests/Observations" - creates it if necessary 1391 * 1392 * @param rep The repetition index (0-indexed) 1393 */ 1394 public CE getReflexTestsObservations(int rep) { 1395 CE retVal = this.getTypedField(34, rep); 1396 return retVal; 1397 } 1398 1399 /** 1400 * Returns a specific repetition of 1401 * OM1-34: "Reflex Tests/Observations" - creates it if necessary 1402 * 1403 * @param rep The repetition index (0-indexed) 1404 */ 1405 public CE getOm134_ReflexTestsObservations(int rep) { 1406 CE retVal = this.getTypedField(34, rep); 1407 return retVal; 1408 } 1409 1410 /** 1411 * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34). 1412 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1413 * it will return zero. 1414 */ 1415 public int getOm134_ReflexTestsObservationsReps() { 1416 return this.getReps(34); 1417 } 1418 1419 1420 /** 1421 * Inserts a repetition of 1422 * OM1-34: "Reflex Tests/Observations" at a specific index 1423 * 1424 * @param rep The repetition index (0-indexed) 1425 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1426 */ 1427 public CE insertReflexTestsObservations(int rep) throws HL7Exception { 1428 return (CE) super.insertRepetition(34, rep); 1429 } 1430 1431 1432 /** 1433 * Inserts a repetition of 1434 * OM1-34: "Reflex Tests/Observations" at a specific index 1435 * 1436 * @param rep The repetition index (0-indexed) 1437 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1438 */ 1439 public CE insertOm134_ReflexTestsObservations(int rep) throws HL7Exception { 1440 return (CE) super.insertRepetition(34, rep); 1441 } 1442 1443 1444 /** 1445 * Removes a repetition of 1446 * OM1-34: "Reflex Tests/Observations" at a specific index 1447 * 1448 * @param rep The repetition index (0-indexed) 1449 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1450 */ 1451 public CE removeReflexTestsObservations(int rep) throws HL7Exception { 1452 return (CE) super.removeRepetition(34, rep); 1453 } 1454 1455 1456 /** 1457 * Removes a repetition of 1458 * OM1-34: "Reflex Tests/Observations" at a specific index 1459 * 1460 * @param rep The repetition index (0-indexed) 1461 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1462 */ 1463 public CE removeOm134_ReflexTestsObservations(int rep) throws HL7Exception { 1464 return (CE) super.removeRepetition(34, rep); 1465 } 1466 1467 1468 1469 1470 /** 1471 * Returns 1472 * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary 1473 */ 1474 public ST getRulesThatTriggerReflexTesting() { 1475 ST retVal = this.getTypedField(35, 0); 1476 return retVal; 1477 } 1478 1479 /** 1480 * Returns 1481 * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary 1482 */ 1483 public ST getOm135_RulesThatTriggerReflexTesting() { 1484 ST retVal = this.getTypedField(35, 0); 1485 return retVal; 1486 } 1487 1488 1489 1490 /** 1491 * Returns 1492 * OM1-36: "Fixed Canned Message" - creates it if necessary 1493 */ 1494 public CE getFixedCannedMessage() { 1495 CE retVal = this.getTypedField(36, 0); 1496 return retVal; 1497 } 1498 1499 /** 1500 * Returns 1501 * OM1-36: "Fixed Canned Message" - creates it if necessary 1502 */ 1503 public CE getOm136_FixedCannedMessage() { 1504 CE retVal = this.getTypedField(36, 0); 1505 return retVal; 1506 } 1507 1508 1509 1510 /** 1511 * Returns 1512 * OM1-37: "Patient Preparation" - creates it if necessary 1513 */ 1514 public TX getPatientPreparation() { 1515 TX retVal = this.getTypedField(37, 0); 1516 return retVal; 1517 } 1518 1519 /** 1520 * Returns 1521 * OM1-37: "Patient Preparation" - creates it if necessary 1522 */ 1523 public TX getOm137_PatientPreparation() { 1524 TX retVal = this.getTypedField(37, 0); 1525 return retVal; 1526 } 1527 1528 1529 1530 /** 1531 * Returns 1532 * OM1-38: "Procedure Medication" - creates it if necessary 1533 */ 1534 public CE getProcedureMedication() { 1535 CE retVal = this.getTypedField(38, 0); 1536 return retVal; 1537 } 1538 1539 /** 1540 * Returns 1541 * OM1-38: "Procedure Medication" - creates it if necessary 1542 */ 1543 public CE getOm138_ProcedureMedication() { 1544 CE retVal = this.getTypedField(38, 0); 1545 return retVal; 1546 } 1547 1548 1549 1550 /** 1551 * Returns 1552 * OM1-39: "Factors that may Effect the Observation" - creates it if necessary 1553 */ 1554 public TX getFactorsThatMayEffectTheObservation() { 1555 TX retVal = this.getTypedField(39, 0); 1556 return retVal; 1557 } 1558 1559 /** 1560 * Returns 1561 * OM1-39: "Factors that may Effect the Observation" - creates it if necessary 1562 */ 1563 public TX getOm139_FactorsThatMayEffectTheObservation() { 1564 TX retVal = this.getTypedField(39, 0); 1565 return retVal; 1566 } 1567 1568 1569 /** 1570 * Returns all repetitions of Test/Observation Performance Schedule (OM1-40). 1571 */ 1572 public ST[] getTestObservationPerformanceSchedule() { 1573 ST[] retVal = this.getTypedField(40, new ST[0]); 1574 return retVal; 1575 } 1576 1577 1578 /** 1579 * Returns all repetitions of Test/Observation Performance Schedule (OM1-40). 1580 */ 1581 public ST[] getOm140_TestObservationPerformanceSchedule() { 1582 ST[] retVal = this.getTypedField(40, new ST[0]); 1583 return retVal; 1584 } 1585 1586 1587 /** 1588 * Returns a count of the current number of repetitions of Test/Observation Performance Schedule (OM1-40). 1589 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1590 * it will return zero. 1591 */ 1592 public int getTestObservationPerformanceScheduleReps() { 1593 return this.getReps(40); 1594 } 1595 1596 1597 /** 1598 * Returns a specific repetition of 1599 * OM1-40: "Test/Observation Performance Schedule" - creates it if necessary 1600 * 1601 * @param rep The repetition index (0-indexed) 1602 */ 1603 public ST getTestObservationPerformanceSchedule(int rep) { 1604 ST retVal = this.getTypedField(40, rep); 1605 return retVal; 1606 } 1607 1608 /** 1609 * Returns a specific repetition of 1610 * OM1-40: "Test/Observation Performance Schedule" - creates it if necessary 1611 * 1612 * @param rep The repetition index (0-indexed) 1613 */ 1614 public ST getOm140_TestObservationPerformanceSchedule(int rep) { 1615 ST retVal = this.getTypedField(40, rep); 1616 return retVal; 1617 } 1618 1619 /** 1620 * Returns a count of the current number of repetitions of Test/Observation Performance Schedule (OM1-40). 1621 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1622 * it will return zero. 1623 */ 1624 public int getOm140_TestObservationPerformanceScheduleReps() { 1625 return this.getReps(40); 1626 } 1627 1628 1629 /** 1630 * Inserts a repetition of 1631 * OM1-40: "Test/Observation Performance Schedule" at a specific index 1632 * 1633 * @param rep The repetition index (0-indexed) 1634 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1635 */ 1636 public ST insertTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1637 return (ST) super.insertRepetition(40, rep); 1638 } 1639 1640 1641 /** 1642 * Inserts a repetition of 1643 * OM1-40: "Test/Observation Performance Schedule" at a specific index 1644 * 1645 * @param rep The repetition index (0-indexed) 1646 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1647 */ 1648 public ST insertOm140_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 1649 return (ST) super.insertRepetition(40, rep); 1650 } 1651 1652 1653 /** 1654 * Removes a repetition of 1655 * OM1-40: "Test/Observation Performance Schedule" at a specific index 1656 * 1657 * @param rep The repetition index (0-indexed) 1658 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1659 */ 1660 public ST removeTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1661 return (ST) super.removeRepetition(40, rep); 1662 } 1663 1664 1665 /** 1666 * Removes a repetition of 1667 * OM1-40: "Test/Observation Performance Schedule" at a specific index 1668 * 1669 * @param rep The repetition index (0-indexed) 1670 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1671 */ 1672 public ST removeOm140_TestObservationPerformanceSchedule(int rep) throws HL7Exception { 1673 return (ST) super.removeRepetition(40, rep); 1674 } 1675 1676 1677 1678 1679 /** 1680 * Returns 1681 * OM1-41: "Description of Test Methods" - creates it if necessary 1682 */ 1683 public TX getDescriptionOfTestMethods() { 1684 TX retVal = this.getTypedField(41, 0); 1685 return retVal; 1686 } 1687 1688 /** 1689 * Returns 1690 * OM1-41: "Description of Test Methods" - creates it if necessary 1691 */ 1692 public TX getOm141_DescriptionOfTestMethods() { 1693 TX retVal = this.getTypedField(41, 0); 1694 return retVal; 1695 } 1696 1697 1698 1699 /** 1700 * Returns 1701 * OM1-42: "Kind of Quantity Observed" - creates it if necessary 1702 */ 1703 public CE getKindOfQuantityObserved() { 1704 CE retVal = this.getTypedField(42, 0); 1705 return retVal; 1706 } 1707 1708 /** 1709 * Returns 1710 * OM1-42: "Kind of Quantity Observed" - creates it if necessary 1711 */ 1712 public CE getOm142_KindOfQuantityObserved() { 1713 CE retVal = this.getTypedField(42, 0); 1714 return retVal; 1715 } 1716 1717 1718 1719 /** 1720 * Returns 1721 * OM1-43: "Point versus Interval" - creates it if necessary 1722 */ 1723 public CE getPointVersusInterval() { 1724 CE retVal = this.getTypedField(43, 0); 1725 return retVal; 1726 } 1727 1728 /** 1729 * Returns 1730 * OM1-43: "Point versus Interval" - creates it if necessary 1731 */ 1732 public CE getOm143_PointVersusInterval() { 1733 CE retVal = this.getTypedField(43, 0); 1734 return retVal; 1735 } 1736 1737 1738 1739 /** 1740 * Returns 1741 * OM1-44: "Challenge information" - creates it if necessary 1742 */ 1743 public TX getChallengeInformation() { 1744 TX retVal = this.getTypedField(44, 0); 1745 return retVal; 1746 } 1747 1748 /** 1749 * Returns 1750 * OM1-44: "Challenge information" - creates it if necessary 1751 */ 1752 public TX getOm144_ChallengeInformation() { 1753 TX retVal = this.getTypedField(44, 0); 1754 return retVal; 1755 } 1756 1757 1758 1759 /** 1760 * Returns 1761 * OM1-45: "Relationship modifier" - creates it if necessary 1762 */ 1763 public CE getRelationshipModifier() { 1764 CE retVal = this.getTypedField(45, 0); 1765 return retVal; 1766 } 1767 1768 /** 1769 * Returns 1770 * OM1-45: "Relationship modifier" - creates it if necessary 1771 */ 1772 public CE getOm145_RelationshipModifier() { 1773 CE retVal = this.getTypedField(45, 0); 1774 return retVal; 1775 } 1776 1777 1778 1779 /** 1780 * Returns 1781 * OM1-46: "Target anatomic site of test" - creates it if necessary 1782 */ 1783 public CE getTargetAnatomicSiteOfTest() { 1784 CE retVal = this.getTypedField(46, 0); 1785 return retVal; 1786 } 1787 1788 /** 1789 * Returns 1790 * OM1-46: "Target anatomic site of test" - creates it if necessary 1791 */ 1792 public CE getOm146_TargetAnatomicSiteOfTest() { 1793 CE retVal = this.getTypedField(46, 0); 1794 return retVal; 1795 } 1796 1797 1798 1799 /** 1800 * Returns 1801 * OM1-47: "Modality of imaging measurement" - creates it if necessary 1802 */ 1803 public CE getModalityOfImagingMeasurement() { 1804 CE retVal = this.getTypedField(47, 0); 1805 return retVal; 1806 } 1807 1808 /** 1809 * Returns 1810 * OM1-47: "Modality of imaging measurement" - creates it if necessary 1811 */ 1812 public CE getOm147_ModalityOfImagingMeasurement() { 1813 CE retVal = this.getTypedField(47, 0); 1814 return retVal; 1815 } 1816 1817 1818 1819 1820 1821 /** {@inheritDoc} */ 1822 protected Type createNewTypeWithoutReflection(int field) { 1823 switch (field) { 1824 case 0: return new NM(getMessage()); 1825 case 1: return new CE(getMessage()); 1826 case 2: return new ID(getMessage(), new Integer( 125 )); 1827 case 3: return new ID(getMessage(), new Integer( 136 )); 1828 case 4: return new CE(getMessage()); 1829 case 5: return new CE(getMessage()); 1830 case 6: return new CE(getMessage()); 1831 case 7: return new ST(getMessage()); 1832 case 8: return new ST(getMessage()); 1833 case 9: return new ST(getMessage()); 1834 case 10: return new ST(getMessage()); 1835 case 11: return new ID(getMessage(), new Integer( 136 )); 1836 case 12: return new CE(getMessage()); 1837 case 13: return new CE(getMessage()); 1838 case 14: return new ID(getMessage(), new Integer( 136 )); 1839 case 15: return new CE(getMessage()); 1840 case 16: return new TN(getMessage()); 1841 case 17: return new ID(getMessage(), new Integer( 174 )); 1842 case 18: return new CE(getMessage()); 1843 case 19: return new ST(getMessage()); 1844 case 20: return new TS(getMessage()); 1845 case 21: return new TS(getMessage()); 1846 case 22: return new NM(getMessage()); 1847 case 23: return new NM(getMessage()); 1848 case 24: return new ID(getMessage(), new Integer( 168 )); 1849 case 25: return new ID(getMessage(), new Integer( 169 )); 1850 case 26: return new CE(getMessage()); 1851 case 27: return new AD(getMessage()); 1852 case 28: return new TN(getMessage()); 1853 case 29: return new ID(getMessage(), new Integer( 177 )); 1854 case 30: return new CE(getMessage()); 1855 case 31: return new TX(getMessage()); 1856 case 32: return new CE(getMessage()); 1857 case 33: return new CE(getMessage()); 1858 case 34: return new ST(getMessage()); 1859 case 35: return new CE(getMessage()); 1860 case 36: return new TX(getMessage()); 1861 case 37: return new CE(getMessage()); 1862 case 38: return new TX(getMessage()); 1863 case 39: return new ST(getMessage()); 1864 case 40: return new TX(getMessage()); 1865 case 41: return new CE(getMessage()); 1866 case 42: return new CE(getMessage()); 1867 case 43: return new TX(getMessage()); 1868 case 44: return new CE(getMessage()); 1869 case 45: return new CE(getMessage()); 1870 case 46: return new CE(getMessage()); 1871 default: return null; 1872 } 1873 } 1874 1875 1876} 1877