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