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.v24.segment; 035 036// import ca.uhn.hl7v2.model.v24.group.*; 037import ca.uhn.hl7v2.model.v24.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 Segment). 049 * This segment has the following fields:</p> 050 * <ul> 051 * <li>OM1-1: Sequence Number - Test/ Observation Master File (NM) <b> </b> 052 * <li>OM1-2: Producer's Service/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 (TX) <b>optional </b> 057 * <li>OM1-7: Other Service/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 Perform this Study (CE) <b>optional repeating</b> 064 * <li>OM1-14: Coded Representation of Method (CE) <b>optional repeating</b> 065 * <li>OM1-15: Portable Device Indicator (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 (XTN) <b>optional </b> 068 * <li>OM1-18: Nature of Service/Test/Observation (IS) <b> </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 Definition for the Observation (TS) <b>optional </b> 072 * <li>OM1-22: Effective Date/Time of Change (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) (XAD) <b>optional repeating</b> 079 * <li>OM1-29: Phone Number of Outside Site (XTN) <b>optional </b> 080 * <li>OM1-30: Confidentiality Code (IS) <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 (TX) <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 Affect Affect the Observation (TX) <b>optional </b> 090 * <li>OM1-40: Service/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, true, 1, 4, new Object[]{ getMessage() }, "Sequence Number - Test/ Observation Master File"); 114 this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Producer's Service/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, 250, new Object[]{ getMessage() }, "Producer ID"); 118 this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Observation Description"); 119 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Other Service/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, 250, new Object[]{ getMessage() }, "Identity of Instrument Used to Perform this Study"); 126 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Coded Representation of Method"); 127 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Portable Device Indicator"); 128 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Observation Producing Department/Section"); 129 this.add(XTN.class, false, 1, 250, new Object[]{ getMessage() }, "Telephone Number of Section"); 130 this.add(IS.class, true, 1, 1, new Object[]{ getMessage(), new Integer(174) }, "Nature of Service/Test/Observation"); 131 this.add(CE.class, false, 1, 250, 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 Definition for the Observation"); 134 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date/Time of Change"); 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, 250, new Object[]{ getMessage() }, "Outside Site(s) Where Observation may be Performed"); 140 this.add(XAD.class, false, 0, 1000, new Object[]{ getMessage() }, "Address of Outside Site(s)"); 141 this.add(XTN.class, false, 1, 400, new Object[]{ getMessage() }, "Phone Number of Outside Site"); 142 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(177) }, "Confidentiality Code"); 143 this.add(CE.class, false, 1, 250, 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, 250, new Object[]{ getMessage() }, "Reflex Tests/Observations"); 147 this.add(TX.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, 250, new Object[]{ getMessage() }, "Procedure Medication"); 151 this.add(TX.class, false, 1, 200, new Object[]{ getMessage() }, "Factors that may Affect Affect the Observation"); 152 this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Service/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, 250, new Object[]{ getMessage() }, "Kind of Quantity Observed"); 155 this.add(CE.class, false, 1, 250, 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, 250, new Object[]{ getMessage() }, "Relationship Modifier"); 158 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Target Anatomic Site Of Test"); 159 this.add(CE.class, false, 1, 250, 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 Service/Test/Observation ID" - creates it if necessary 190 */ 191 public CE getProducerSServiceTestObservationID() { 192 CE retVal = this.getTypedField(2, 0); 193 return retVal; 194 } 195 196 /** 197 * Returns 198 * OM1-2: "Producer's Service/Test/Observation ID" - creates it if necessary 199 */ 200 public CE getOm12_ProducerSServiceTestObservationID() { 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 TX getObservationDescription() { 361 TX 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 TX getOm16_ObservationDescription() { 370 TX retVal = this.getTypedField(6, 0); 371 return retVal; 372 } 373 374 375 376 /** 377 * Returns 378 * OM1-7: "Other Service/Test/Observation IDs for the Observation" - creates it if necessary 379 */ 380 public CE getOtherServiceTestObservationIDsForTheObservation() { 381 CE retVal = this.getTypedField(7, 0); 382 return retVal; 383 } 384 385 /** 386 * Returns 387 * OM1-7: "Other Service/Test/Observation IDs for the Observation" - creates it if necessary 388 */ 389 public CE getOm17_OtherServiceTestObservationIDsForTheObservation() { 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 Perform this Study (OM1-13). 586 */ 587 public CE[] getIdentityOfInstrumentUsedToPerformThisStudy() { 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 Perform this Study (OM1-13). 595 */ 596 public CE[] getOm113_IdentityOfInstrumentUsedToPerformThisStudy() { 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 Perform 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 getIdentityOfInstrumentUsedToPerformThisStudyReps() { 608 return this.getReps(13); 609 } 610 611 612 /** 613 * Returns a specific repetition of 614 * OM1-13: "Identity of Instrument Used to Perform this Study" - creates it if necessary 615 * 616 * @param rep The repetition index (0-indexed) 617 */ 618 public CE getIdentityOfInstrumentUsedToPerformThisStudy(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 Perform this Study" - creates it if necessary 626 * 627 * @param rep The repetition index (0-indexed) 628 */ 629 public CE getOm113_IdentityOfInstrumentUsedToPerformThisStudy(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 Perform 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_IdentityOfInstrumentUsedToPerformThisStudyReps() { 640 return this.getReps(13); 641 } 642 643 644 /** 645 * Inserts a repetition of 646 * OM1-13: "Identity of Instrument Used to Perform 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 insertIdentityOfInstrumentUsedToPerformThisStudy(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 Perform 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_IdentityOfInstrumentUsedToPerformThisStudy(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 Perform 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 removeIdentityOfInstrumentUsedToPerformThisStudy(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 Perform 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_IdentityOfInstrumentUsedToPerformThisStudy(int rep) throws HL7Exception { 688 return (CE) super.removeRepetition(13, rep); 689 } 690 691 692 693 /** 694 * Returns all repetitions of Coded Representation of Method (OM1-14). 695 */ 696 public CE[] getCodedRepresentationOfMethod() { 697 CE[] retVal = this.getTypedField(14, new CE[0]); 698 return retVal; 699 } 700 701 702 /** 703 * Returns all repetitions of Coded Representation of Method (OM1-14). 704 */ 705 public CE[] getOm114_CodedRepresentationOfMethod() { 706 CE[] retVal = this.getTypedField(14, new CE[0]); 707 return retVal; 708 } 709 710 711 /** 712 * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-14). 713 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 714 * it will return zero. 715 */ 716 public int getCodedRepresentationOfMethodReps() { 717 return this.getReps(14); 718 } 719 720 721 /** 722 * Returns a specific repetition of 723 * OM1-14: "Coded Representation of Method" - creates it if necessary 724 * 725 * @param rep The repetition index (0-indexed) 726 */ 727 public CE getCodedRepresentationOfMethod(int rep) { 728 CE retVal = this.getTypedField(14, rep); 729 return retVal; 730 } 731 732 /** 733 * Returns a specific repetition of 734 * OM1-14: "Coded Representation of Method" - creates it if necessary 735 * 736 * @param rep The repetition index (0-indexed) 737 */ 738 public CE getOm114_CodedRepresentationOfMethod(int rep) { 739 CE retVal = this.getTypedField(14, rep); 740 return retVal; 741 } 742 743 /** 744 * Returns a count of the current number of repetitions of Coded Representation of Method (OM1-14). 745 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 746 * it will return zero. 747 */ 748 public int getOm114_CodedRepresentationOfMethodReps() { 749 return this.getReps(14); 750 } 751 752 753 /** 754 * Inserts a repetition of 755 * OM1-14: "Coded Representation of Method" at a specific index 756 * 757 * @param rep The repetition index (0-indexed) 758 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 759 */ 760 public CE insertCodedRepresentationOfMethod(int rep) throws HL7Exception { 761 return (CE) super.insertRepetition(14, rep); 762 } 763 764 765 /** 766 * Inserts a repetition of 767 * OM1-14: "Coded Representation of Method" at a specific index 768 * 769 * @param rep The repetition index (0-indexed) 770 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 771 */ 772 public CE insertOm114_CodedRepresentationOfMethod(int rep) throws HL7Exception { 773 return (CE) super.insertRepetition(14, rep); 774 } 775 776 777 /** 778 * Removes a repetition of 779 * OM1-14: "Coded Representation of Method" at a specific index 780 * 781 * @param rep The repetition index (0-indexed) 782 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 783 */ 784 public CE removeCodedRepresentationOfMethod(int rep) throws HL7Exception { 785 return (CE) super.removeRepetition(14, rep); 786 } 787 788 789 /** 790 * Removes a repetition of 791 * OM1-14: "Coded Representation of Method" at a specific index 792 * 793 * @param rep The repetition index (0-indexed) 794 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 795 */ 796 public CE removeOm114_CodedRepresentationOfMethod(int rep) throws HL7Exception { 797 return (CE) super.removeRepetition(14, rep); 798 } 799 800 801 802 803 /** 804 * Returns 805 * OM1-15: "Portable Device Indicator" - creates it if necessary 806 */ 807 public ID getPortableDeviceIndicator() { 808 ID retVal = this.getTypedField(15, 0); 809 return retVal; 810 } 811 812 /** 813 * Returns 814 * OM1-15: "Portable Device Indicator" - creates it if necessary 815 */ 816 public ID getOm115_PortableDeviceIndicator() { 817 ID retVal = this.getTypedField(15, 0); 818 return retVal; 819 } 820 821 822 /** 823 * Returns all repetitions of Observation Producing Department/Section (OM1-16). 824 */ 825 public CE[] getObservationProducingDepartmentSection() { 826 CE[] retVal = this.getTypedField(16, new CE[0]); 827 return retVal; 828 } 829 830 831 /** 832 * Returns all repetitions of Observation Producing Department/Section (OM1-16). 833 */ 834 public CE[] getOm116_ObservationProducingDepartmentSection() { 835 CE[] retVal = this.getTypedField(16, new CE[0]); 836 return retVal; 837 } 838 839 840 /** 841 * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16). 842 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 843 * it will return zero. 844 */ 845 public int getObservationProducingDepartmentSectionReps() { 846 return this.getReps(16); 847 } 848 849 850 /** 851 * Returns a specific repetition of 852 * OM1-16: "Observation Producing Department/Section" - creates it if necessary 853 * 854 * @param rep The repetition index (0-indexed) 855 */ 856 public CE getObservationProducingDepartmentSection(int rep) { 857 CE retVal = this.getTypedField(16, rep); 858 return retVal; 859 } 860 861 /** 862 * Returns a specific repetition of 863 * OM1-16: "Observation Producing Department/Section" - creates it if necessary 864 * 865 * @param rep The repetition index (0-indexed) 866 */ 867 public CE getOm116_ObservationProducingDepartmentSection(int rep) { 868 CE retVal = this.getTypedField(16, rep); 869 return retVal; 870 } 871 872 /** 873 * Returns a count of the current number of repetitions of Observation Producing Department/Section (OM1-16). 874 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 875 * it will return zero. 876 */ 877 public int getOm116_ObservationProducingDepartmentSectionReps() { 878 return this.getReps(16); 879 } 880 881 882 /** 883 * Inserts a repetition of 884 * OM1-16: "Observation Producing Department/Section" at a specific index 885 * 886 * @param rep The repetition index (0-indexed) 887 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 888 */ 889 public CE insertObservationProducingDepartmentSection(int rep) throws HL7Exception { 890 return (CE) super.insertRepetition(16, rep); 891 } 892 893 894 /** 895 * Inserts a repetition of 896 * OM1-16: "Observation Producing Department/Section" at a specific index 897 * 898 * @param rep The repetition index (0-indexed) 899 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 900 */ 901 public CE insertOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 902 return (CE) super.insertRepetition(16, rep); 903 } 904 905 906 /** 907 * Removes a repetition of 908 * OM1-16: "Observation Producing Department/Section" at a specific index 909 * 910 * @param rep The repetition index (0-indexed) 911 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 912 */ 913 public CE removeObservationProducingDepartmentSection(int rep) throws HL7Exception { 914 return (CE) super.removeRepetition(16, rep); 915 } 916 917 918 /** 919 * Removes a repetition of 920 * OM1-16: "Observation Producing Department/Section" at a specific index 921 * 922 * @param rep The repetition index (0-indexed) 923 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 924 */ 925 public CE removeOm116_ObservationProducingDepartmentSection(int rep) throws HL7Exception { 926 return (CE) super.removeRepetition(16, rep); 927 } 928 929 930 931 932 /** 933 * Returns 934 * OM1-17: "Telephone Number of Section" - creates it if necessary 935 */ 936 public XTN getTelephoneNumberOfSection() { 937 XTN retVal = this.getTypedField(17, 0); 938 return retVal; 939 } 940 941 /** 942 * Returns 943 * OM1-17: "Telephone Number of Section" - creates it if necessary 944 */ 945 public XTN getOm117_TelephoneNumberOfSection() { 946 XTN retVal = this.getTypedField(17, 0); 947 return retVal; 948 } 949 950 951 952 /** 953 * Returns 954 * OM1-18: "Nature of Service/Test/Observation" - creates it if necessary 955 */ 956 public IS getNatureOfServiceTestObservation() { 957 IS retVal = this.getTypedField(18, 0); 958 return retVal; 959 } 960 961 /** 962 * Returns 963 * OM1-18: "Nature of Service/Test/Observation" - creates it if necessary 964 */ 965 public IS getOm118_NatureOfServiceTestObservation() { 966 IS retVal = this.getTypedField(18, 0); 967 return retVal; 968 } 969 970 971 972 /** 973 * Returns 974 * OM1-19: "Report Subheader" - creates it if necessary 975 */ 976 public CE getReportSubheader() { 977 CE retVal = this.getTypedField(19, 0); 978 return retVal; 979 } 980 981 /** 982 * Returns 983 * OM1-19: "Report Subheader" - creates it if necessary 984 */ 985 public CE getOm119_ReportSubheader() { 986 CE retVal = this.getTypedField(19, 0); 987 return retVal; 988 } 989 990 991 992 /** 993 * Returns 994 * OM1-20: "Report Display Order" - creates it if necessary 995 */ 996 public ST getReportDisplayOrder() { 997 ST retVal = this.getTypedField(20, 0); 998 return retVal; 999 } 1000 1001 /** 1002 * Returns 1003 * OM1-20: "Report Display Order" - creates it if necessary 1004 */ 1005 public ST getOm120_ReportDisplayOrder() { 1006 ST retVal = this.getTypedField(20, 0); 1007 return retVal; 1008 } 1009 1010 1011 1012 /** 1013 * Returns 1014 * OM1-21: "Date/Time Stamp for any change in Definition for the Observation" - creates it if necessary 1015 */ 1016 public TS getDateTimeStampForAnyChangeInDefinitionForTheObservation() { 1017 TS retVal = this.getTypedField(21, 0); 1018 return retVal; 1019 } 1020 1021 /** 1022 * Returns 1023 * OM1-21: "Date/Time Stamp for any change in Definition for the Observation" - creates it if necessary 1024 */ 1025 public TS getOm121_DateTimeStampForAnyChangeInDefinitionForTheObservation() { 1026 TS retVal = this.getTypedField(21, 0); 1027 return retVal; 1028 } 1029 1030 1031 1032 /** 1033 * Returns 1034 * OM1-22: "Effective Date/Time of Change" - creates it if necessary 1035 */ 1036 public TS getEffectiveDateTimeOfChange() { 1037 TS retVal = this.getTypedField(22, 0); 1038 return retVal; 1039 } 1040 1041 /** 1042 * Returns 1043 * OM1-22: "Effective Date/Time of Change" - creates it if necessary 1044 */ 1045 public TS getOm122_EffectiveDateTimeOfChange() { 1046 TS retVal = this.getTypedField(22, 0); 1047 return retVal; 1048 } 1049 1050 1051 1052 /** 1053 * Returns 1054 * OM1-23: "Typical Turn-Around Time" - creates it if necessary 1055 */ 1056 public NM getTypicalTurnAroundTime() { 1057 NM retVal = this.getTypedField(23, 0); 1058 return retVal; 1059 } 1060 1061 /** 1062 * Returns 1063 * OM1-23: "Typical Turn-Around Time" - creates it if necessary 1064 */ 1065 public NM getOm123_TypicalTurnAroundTime() { 1066 NM retVal = this.getTypedField(23, 0); 1067 return retVal; 1068 } 1069 1070 1071 1072 /** 1073 * Returns 1074 * OM1-24: "Processing Time" - creates it if necessary 1075 */ 1076 public NM getProcessingTime() { 1077 NM retVal = this.getTypedField(24, 0); 1078 return retVal; 1079 } 1080 1081 /** 1082 * Returns 1083 * OM1-24: "Processing Time" - creates it if necessary 1084 */ 1085 public NM getOm124_ProcessingTime() { 1086 NM retVal = this.getTypedField(24, 0); 1087 return retVal; 1088 } 1089 1090 1091 /** 1092 * Returns all repetitions of Processing Priority (OM1-25). 1093 */ 1094 public ID[] getProcessingPriority() { 1095 ID[] retVal = this.getTypedField(25, new ID[0]); 1096 return retVal; 1097 } 1098 1099 1100 /** 1101 * Returns all repetitions of Processing Priority (OM1-25). 1102 */ 1103 public ID[] getOm125_ProcessingPriority() { 1104 ID[] retVal = this.getTypedField(25, new ID[0]); 1105 return retVal; 1106 } 1107 1108 1109 /** 1110 * Returns a count of the current number of repetitions of Processing Priority (OM1-25). 1111 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1112 * it will return zero. 1113 */ 1114 public int getProcessingPriorityReps() { 1115 return this.getReps(25); 1116 } 1117 1118 1119 /** 1120 * Returns a specific repetition of 1121 * OM1-25: "Processing Priority" - creates it if necessary 1122 * 1123 * @param rep The repetition index (0-indexed) 1124 */ 1125 public ID getProcessingPriority(int rep) { 1126 ID retVal = this.getTypedField(25, rep); 1127 return retVal; 1128 } 1129 1130 /** 1131 * Returns a specific repetition of 1132 * OM1-25: "Processing Priority" - creates it if necessary 1133 * 1134 * @param rep The repetition index (0-indexed) 1135 */ 1136 public ID getOm125_ProcessingPriority(int rep) { 1137 ID retVal = this.getTypedField(25, rep); 1138 return retVal; 1139 } 1140 1141 /** 1142 * Returns a count of the current number of repetitions of Processing Priority (OM1-25). 1143 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1144 * it will return zero. 1145 */ 1146 public int getOm125_ProcessingPriorityReps() { 1147 return this.getReps(25); 1148 } 1149 1150 1151 /** 1152 * Inserts a repetition of 1153 * OM1-25: "Processing Priority" at a specific index 1154 * 1155 * @param rep The repetition index (0-indexed) 1156 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1157 */ 1158 public ID insertProcessingPriority(int rep) throws HL7Exception { 1159 return (ID) super.insertRepetition(25, rep); 1160 } 1161 1162 1163 /** 1164 * Inserts a repetition of 1165 * OM1-25: "Processing Priority" at a specific index 1166 * 1167 * @param rep The repetition index (0-indexed) 1168 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1169 */ 1170 public ID insertOm125_ProcessingPriority(int rep) throws HL7Exception { 1171 return (ID) super.insertRepetition(25, rep); 1172 } 1173 1174 1175 /** 1176 * Removes a repetition of 1177 * OM1-25: "Processing Priority" at a specific index 1178 * 1179 * @param rep The repetition index (0-indexed) 1180 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1181 */ 1182 public ID removeProcessingPriority(int rep) throws HL7Exception { 1183 return (ID) super.removeRepetition(25, rep); 1184 } 1185 1186 1187 /** 1188 * Removes a repetition of 1189 * OM1-25: "Processing Priority" at a specific index 1190 * 1191 * @param rep The repetition index (0-indexed) 1192 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1193 */ 1194 public ID removeOm125_ProcessingPriority(int rep) throws HL7Exception { 1195 return (ID) super.removeRepetition(25, rep); 1196 } 1197 1198 1199 1200 1201 /** 1202 * Returns 1203 * OM1-26: "Reporting Priority" - creates it if necessary 1204 */ 1205 public ID getReportingPriority() { 1206 ID retVal = this.getTypedField(26, 0); 1207 return retVal; 1208 } 1209 1210 /** 1211 * Returns 1212 * OM1-26: "Reporting Priority" - creates it if necessary 1213 */ 1214 public ID getOm126_ReportingPriority() { 1215 ID retVal = this.getTypedField(26, 0); 1216 return retVal; 1217 } 1218 1219 1220 /** 1221 * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1222 */ 1223 public CE[] getOutsideSiteSWhereObservationMayBePerformed() { 1224 CE[] retVal = this.getTypedField(27, new CE[0]); 1225 return retVal; 1226 } 1227 1228 1229 /** 1230 * Returns all repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1231 */ 1232 public CE[] getOm127_OutsideSiteSWhereObservationMayBePerformed() { 1233 CE[] retVal = this.getTypedField(27, new CE[0]); 1234 return retVal; 1235 } 1236 1237 1238 /** 1239 * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1240 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1241 * it will return zero. 1242 */ 1243 public int getOutsideSiteSWhereObservationMayBePerformedReps() { 1244 return this.getReps(27); 1245 } 1246 1247 1248 /** 1249 * Returns a specific repetition of 1250 * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary 1251 * 1252 * @param rep The repetition index (0-indexed) 1253 */ 1254 public CE getOutsideSiteSWhereObservationMayBePerformed(int rep) { 1255 CE retVal = this.getTypedField(27, rep); 1256 return retVal; 1257 } 1258 1259 /** 1260 * Returns a specific repetition of 1261 * OM1-27: "Outside Site(s) Where Observation may be Performed" - creates it if necessary 1262 * 1263 * @param rep The repetition index (0-indexed) 1264 */ 1265 public CE getOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) { 1266 CE retVal = this.getTypedField(27, rep); 1267 return retVal; 1268 } 1269 1270 /** 1271 * Returns a count of the current number of repetitions of Outside Site(s) Where Observation may be Performed (OM1-27). 1272 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1273 * it will return zero. 1274 */ 1275 public int getOm127_OutsideSiteSWhereObservationMayBePerformedReps() { 1276 return this.getReps(27); 1277 } 1278 1279 1280 /** 1281 * Inserts a repetition of 1282 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1283 * 1284 * @param rep The repetition index (0-indexed) 1285 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1286 */ 1287 public CE insertOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1288 return (CE) super.insertRepetition(27, rep); 1289 } 1290 1291 1292 /** 1293 * Inserts a repetition of 1294 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1295 * 1296 * @param rep The repetition index (0-indexed) 1297 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1298 */ 1299 public CE insertOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1300 return (CE) super.insertRepetition(27, rep); 1301 } 1302 1303 1304 /** 1305 * Removes a repetition of 1306 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1307 * 1308 * @param rep The repetition index (0-indexed) 1309 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1310 */ 1311 public CE removeOutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1312 return (CE) super.removeRepetition(27, rep); 1313 } 1314 1315 1316 /** 1317 * Removes a repetition of 1318 * OM1-27: "Outside Site(s) Where Observation may be Performed" at a specific index 1319 * 1320 * @param rep The repetition index (0-indexed) 1321 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1322 */ 1323 public CE removeOm127_OutsideSiteSWhereObservationMayBePerformed(int rep) throws HL7Exception { 1324 return (CE) super.removeRepetition(27, rep); 1325 } 1326 1327 1328 1329 /** 1330 * Returns all repetitions of Address of Outside Site(s) (OM1-28). 1331 */ 1332 public XAD[] getAddressOfOutsideSiteS() { 1333 XAD[] retVal = this.getTypedField(28, new XAD[0]); 1334 return retVal; 1335 } 1336 1337 1338 /** 1339 * Returns all repetitions of Address of Outside Site(s) (OM1-28). 1340 */ 1341 public XAD[] getOm128_AddressOfOutsideSiteS() { 1342 XAD[] retVal = this.getTypedField(28, new XAD[0]); 1343 return retVal; 1344 } 1345 1346 1347 /** 1348 * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-28). 1349 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1350 * it will return zero. 1351 */ 1352 public int getAddressOfOutsideSiteSReps() { 1353 return this.getReps(28); 1354 } 1355 1356 1357 /** 1358 * Returns a specific repetition of 1359 * OM1-28: "Address of Outside Site(s)" - creates it if necessary 1360 * 1361 * @param rep The repetition index (0-indexed) 1362 */ 1363 public XAD getAddressOfOutsideSiteS(int rep) { 1364 XAD retVal = this.getTypedField(28, rep); 1365 return retVal; 1366 } 1367 1368 /** 1369 * Returns a specific repetition of 1370 * OM1-28: "Address of Outside Site(s)" - creates it if necessary 1371 * 1372 * @param rep The repetition index (0-indexed) 1373 */ 1374 public XAD getOm128_AddressOfOutsideSiteS(int rep) { 1375 XAD retVal = this.getTypedField(28, rep); 1376 return retVal; 1377 } 1378 1379 /** 1380 * Returns a count of the current number of repetitions of Address of Outside Site(s) (OM1-28). 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 getOm128_AddressOfOutsideSiteSReps() { 1385 return this.getReps(28); 1386 } 1387 1388 1389 /** 1390 * Inserts a repetition of 1391 * OM1-28: "Address of Outside Site(s)" at a specific index 1392 * 1393 * @param rep The repetition index (0-indexed) 1394 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1395 */ 1396 public XAD insertAddressOfOutsideSiteS(int rep) throws HL7Exception { 1397 return (XAD) super.insertRepetition(28, rep); 1398 } 1399 1400 1401 /** 1402 * Inserts a repetition of 1403 * OM1-28: "Address of Outside Site(s)" at a specific index 1404 * 1405 * @param rep The repetition index (0-indexed) 1406 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1407 */ 1408 public XAD insertOm128_AddressOfOutsideSiteS(int rep) throws HL7Exception { 1409 return (XAD) super.insertRepetition(28, rep); 1410 } 1411 1412 1413 /** 1414 * Removes a repetition of 1415 * OM1-28: "Address of Outside Site(s)" at a specific index 1416 * 1417 * @param rep The repetition index (0-indexed) 1418 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1419 */ 1420 public XAD removeAddressOfOutsideSiteS(int rep) throws HL7Exception { 1421 return (XAD) super.removeRepetition(28, rep); 1422 } 1423 1424 1425 /** 1426 * Removes a repetition of 1427 * OM1-28: "Address of Outside Site(s)" at a specific index 1428 * 1429 * @param rep The repetition index (0-indexed) 1430 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1431 */ 1432 public XAD removeOm128_AddressOfOutsideSiteS(int rep) throws HL7Exception { 1433 return (XAD) super.removeRepetition(28, rep); 1434 } 1435 1436 1437 1438 1439 /** 1440 * Returns 1441 * OM1-29: "Phone Number of Outside Site" - creates it if necessary 1442 */ 1443 public XTN getPhoneNumberOfOutsideSite() { 1444 XTN retVal = this.getTypedField(29, 0); 1445 return retVal; 1446 } 1447 1448 /** 1449 * Returns 1450 * OM1-29: "Phone Number of Outside Site" - creates it if necessary 1451 */ 1452 public XTN getOm129_PhoneNumberOfOutsideSite() { 1453 XTN retVal = this.getTypedField(29, 0); 1454 return retVal; 1455 } 1456 1457 1458 1459 /** 1460 * Returns 1461 * OM1-30: "Confidentiality Code" - creates it if necessary 1462 */ 1463 public IS getConfidentialityCode() { 1464 IS retVal = this.getTypedField(30, 0); 1465 return retVal; 1466 } 1467 1468 /** 1469 * Returns 1470 * OM1-30: "Confidentiality Code" - creates it if necessary 1471 */ 1472 public IS getOm130_ConfidentialityCode() { 1473 IS retVal = this.getTypedField(30, 0); 1474 return retVal; 1475 } 1476 1477 1478 1479 /** 1480 * Returns 1481 * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary 1482 */ 1483 public CE getObservationsRequiredToInterpretTheObservation() { 1484 CE retVal = this.getTypedField(31, 0); 1485 return retVal; 1486 } 1487 1488 /** 1489 * Returns 1490 * OM1-31: "Observations Required to Interpret the Observation" - creates it if necessary 1491 */ 1492 public CE getOm131_ObservationsRequiredToInterpretTheObservation() { 1493 CE retVal = this.getTypedField(31, 0); 1494 return retVal; 1495 } 1496 1497 1498 1499 /** 1500 * Returns 1501 * OM1-32: "Interpretation of Observations" - creates it if necessary 1502 */ 1503 public TX getInterpretationOfObservations() { 1504 TX retVal = this.getTypedField(32, 0); 1505 return retVal; 1506 } 1507 1508 /** 1509 * Returns 1510 * OM1-32: "Interpretation of Observations" - creates it if necessary 1511 */ 1512 public TX getOm132_InterpretationOfObservations() { 1513 TX retVal = this.getTypedField(32, 0); 1514 return retVal; 1515 } 1516 1517 1518 1519 /** 1520 * Returns 1521 * OM1-33: "Contraindications to Observations" - creates it if necessary 1522 */ 1523 public CE getContraindicationsToObservations() { 1524 CE retVal = this.getTypedField(33, 0); 1525 return retVal; 1526 } 1527 1528 /** 1529 * Returns 1530 * OM1-33: "Contraindications to Observations" - creates it if necessary 1531 */ 1532 public CE getOm133_ContraindicationsToObservations() { 1533 CE retVal = this.getTypedField(33, 0); 1534 return retVal; 1535 } 1536 1537 1538 /** 1539 * Returns all repetitions of Reflex Tests/Observations (OM1-34). 1540 */ 1541 public CE[] getReflexTestsObservations() { 1542 CE[] retVal = this.getTypedField(34, new CE[0]); 1543 return retVal; 1544 } 1545 1546 1547 /** 1548 * Returns all repetitions of Reflex Tests/Observations (OM1-34). 1549 */ 1550 public CE[] getOm134_ReflexTestsObservations() { 1551 CE[] retVal = this.getTypedField(34, new CE[0]); 1552 return retVal; 1553 } 1554 1555 1556 /** 1557 * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34). 1558 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1559 * it will return zero. 1560 */ 1561 public int getReflexTestsObservationsReps() { 1562 return this.getReps(34); 1563 } 1564 1565 1566 /** 1567 * Returns a specific repetition of 1568 * OM1-34: "Reflex Tests/Observations" - creates it if necessary 1569 * 1570 * @param rep The repetition index (0-indexed) 1571 */ 1572 public CE getReflexTestsObservations(int rep) { 1573 CE retVal = this.getTypedField(34, rep); 1574 return retVal; 1575 } 1576 1577 /** 1578 * Returns a specific repetition of 1579 * OM1-34: "Reflex Tests/Observations" - creates it if necessary 1580 * 1581 * @param rep The repetition index (0-indexed) 1582 */ 1583 public CE getOm134_ReflexTestsObservations(int rep) { 1584 CE retVal = this.getTypedField(34, rep); 1585 return retVal; 1586 } 1587 1588 /** 1589 * Returns a count of the current number of repetitions of Reflex Tests/Observations (OM1-34). 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 getOm134_ReflexTestsObservationsReps() { 1594 return this.getReps(34); 1595 } 1596 1597 1598 /** 1599 * Inserts a repetition of 1600 * OM1-34: "Reflex Tests/Observations" at a specific index 1601 * 1602 * @param rep The repetition index (0-indexed) 1603 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1604 */ 1605 public CE insertReflexTestsObservations(int rep) throws HL7Exception { 1606 return (CE) super.insertRepetition(34, rep); 1607 } 1608 1609 1610 /** 1611 * Inserts a repetition of 1612 * OM1-34: "Reflex Tests/Observations" at a specific index 1613 * 1614 * @param rep The repetition index (0-indexed) 1615 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1616 */ 1617 public CE insertOm134_ReflexTestsObservations(int rep) throws HL7Exception { 1618 return (CE) super.insertRepetition(34, rep); 1619 } 1620 1621 1622 /** 1623 * Removes a repetition of 1624 * OM1-34: "Reflex Tests/Observations" at a specific index 1625 * 1626 * @param rep The repetition index (0-indexed) 1627 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1628 */ 1629 public CE removeReflexTestsObservations(int rep) throws HL7Exception { 1630 return (CE) super.removeRepetition(34, rep); 1631 } 1632 1633 1634 /** 1635 * Removes a repetition of 1636 * OM1-34: "Reflex Tests/Observations" at a specific index 1637 * 1638 * @param rep The repetition index (0-indexed) 1639 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1640 */ 1641 public CE removeOm134_ReflexTestsObservations(int rep) throws HL7Exception { 1642 return (CE) super.removeRepetition(34, rep); 1643 } 1644 1645 1646 1647 1648 /** 1649 * Returns 1650 * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary 1651 */ 1652 public TX getRulesThatTriggerReflexTesting() { 1653 TX retVal = this.getTypedField(35, 0); 1654 return retVal; 1655 } 1656 1657 /** 1658 * Returns 1659 * OM1-35: "Rules that Trigger Reflex Testing" - creates it if necessary 1660 */ 1661 public TX getOm135_RulesThatTriggerReflexTesting() { 1662 TX retVal = this.getTypedField(35, 0); 1663 return retVal; 1664 } 1665 1666 1667 1668 /** 1669 * Returns 1670 * OM1-36: "Fixed Canned Message" - creates it if necessary 1671 */ 1672 public CE getFixedCannedMessage() { 1673 CE retVal = this.getTypedField(36, 0); 1674 return retVal; 1675 } 1676 1677 /** 1678 * Returns 1679 * OM1-36: "Fixed Canned Message" - creates it if necessary 1680 */ 1681 public CE getOm136_FixedCannedMessage() { 1682 CE retVal = this.getTypedField(36, 0); 1683 return retVal; 1684 } 1685 1686 1687 1688 /** 1689 * Returns 1690 * OM1-37: "Patient Preparation" - creates it if necessary 1691 */ 1692 public TX getPatientPreparation() { 1693 TX retVal = this.getTypedField(37, 0); 1694 return retVal; 1695 } 1696 1697 /** 1698 * Returns 1699 * OM1-37: "Patient Preparation" - creates it if necessary 1700 */ 1701 public TX getOm137_PatientPreparation() { 1702 TX retVal = this.getTypedField(37, 0); 1703 return retVal; 1704 } 1705 1706 1707 1708 /** 1709 * Returns 1710 * OM1-38: "Procedure Medication" - creates it if necessary 1711 */ 1712 public CE getProcedureMedication() { 1713 CE retVal = this.getTypedField(38, 0); 1714 return retVal; 1715 } 1716 1717 /** 1718 * Returns 1719 * OM1-38: "Procedure Medication" - creates it if necessary 1720 */ 1721 public CE getOm138_ProcedureMedication() { 1722 CE retVal = this.getTypedField(38, 0); 1723 return retVal; 1724 } 1725 1726 1727 1728 /** 1729 * Returns 1730 * OM1-39: "Factors that may Affect Affect the Observation" - creates it if necessary 1731 */ 1732 public TX getFactorsThatMayAffectAffectTheObservation() { 1733 TX retVal = this.getTypedField(39, 0); 1734 return retVal; 1735 } 1736 1737 /** 1738 * Returns 1739 * OM1-39: "Factors that may Affect Affect the Observation" - creates it if necessary 1740 */ 1741 public TX getOm139_FactorsThatMayAffectAffectTheObservation() { 1742 TX retVal = this.getTypedField(39, 0); 1743 return retVal; 1744 } 1745 1746 1747 /** 1748 * Returns all repetitions of Service/Test/Observation Performance Schedule (OM1-40). 1749 */ 1750 public ST[] getServiceTestObservationPerformanceSchedule() { 1751 ST[] retVal = this.getTypedField(40, new ST[0]); 1752 return retVal; 1753 } 1754 1755 1756 /** 1757 * Returns all repetitions of Service/Test/Observation Performance Schedule (OM1-40). 1758 */ 1759 public ST[] getOm140_ServiceTestObservationPerformanceSchedule() { 1760 ST[] retVal = this.getTypedField(40, new ST[0]); 1761 return retVal; 1762 } 1763 1764 1765 /** 1766 * Returns a count of the current number of repetitions of Service/Test/Observation Performance Schedule (OM1-40). 1767 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1768 * it will return zero. 1769 */ 1770 public int getServiceTestObservationPerformanceScheduleReps() { 1771 return this.getReps(40); 1772 } 1773 1774 1775 /** 1776 * Returns a specific repetition of 1777 * OM1-40: "Service/Test/Observation Performance Schedule" - creates it if necessary 1778 * 1779 * @param rep The repetition index (0-indexed) 1780 */ 1781 public ST getServiceTestObservationPerformanceSchedule(int rep) { 1782 ST retVal = this.getTypedField(40, rep); 1783 return retVal; 1784 } 1785 1786 /** 1787 * Returns a specific repetition of 1788 * OM1-40: "Service/Test/Observation Performance Schedule" - creates it if necessary 1789 * 1790 * @param rep The repetition index (0-indexed) 1791 */ 1792 public ST getOm140_ServiceTestObservationPerformanceSchedule(int rep) { 1793 ST retVal = this.getTypedField(40, rep); 1794 return retVal; 1795 } 1796 1797 /** 1798 * Returns a count of the current number of repetitions of Service/Test/Observation Performance Schedule (OM1-40). 1799 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1800 * it will return zero. 1801 */ 1802 public int getOm140_ServiceTestObservationPerformanceScheduleReps() { 1803 return this.getReps(40); 1804 } 1805 1806 1807 /** 1808 * Inserts a repetition of 1809 * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index 1810 * 1811 * @param rep The repetition index (0-indexed) 1812 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1813 */ 1814 public ST insertServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1815 return (ST) super.insertRepetition(40, rep); 1816 } 1817 1818 1819 /** 1820 * Inserts a repetition of 1821 * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index 1822 * 1823 * @param rep The repetition index (0-indexed) 1824 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1825 */ 1826 public ST insertOm140_ServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1827 return (ST) super.insertRepetition(40, rep); 1828 } 1829 1830 1831 /** 1832 * Removes a repetition of 1833 * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index 1834 * 1835 * @param rep The repetition index (0-indexed) 1836 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1837 */ 1838 public ST removeServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1839 return (ST) super.removeRepetition(40, rep); 1840 } 1841 1842 1843 /** 1844 * Removes a repetition of 1845 * OM1-40: "Service/Test/Observation Performance Schedule" at a specific index 1846 * 1847 * @param rep The repetition index (0-indexed) 1848 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1849 */ 1850 public ST removeOm140_ServiceTestObservationPerformanceSchedule(int rep) throws HL7Exception { 1851 return (ST) super.removeRepetition(40, rep); 1852 } 1853 1854 1855 1856 1857 /** 1858 * Returns 1859 * OM1-41: "Description of Test Methods" - creates it if necessary 1860 */ 1861 public TX getDescriptionOfTestMethods() { 1862 TX retVal = this.getTypedField(41, 0); 1863 return retVal; 1864 } 1865 1866 /** 1867 * Returns 1868 * OM1-41: "Description of Test Methods" - creates it if necessary 1869 */ 1870 public TX getOm141_DescriptionOfTestMethods() { 1871 TX retVal = this.getTypedField(41, 0); 1872 return retVal; 1873 } 1874 1875 1876 1877 /** 1878 * Returns 1879 * OM1-42: "Kind of Quantity Observed" - creates it if necessary 1880 */ 1881 public CE getKindOfQuantityObserved() { 1882 CE retVal = this.getTypedField(42, 0); 1883 return retVal; 1884 } 1885 1886 /** 1887 * Returns 1888 * OM1-42: "Kind of Quantity Observed" - creates it if necessary 1889 */ 1890 public CE getOm142_KindOfQuantityObserved() { 1891 CE retVal = this.getTypedField(42, 0); 1892 return retVal; 1893 } 1894 1895 1896 1897 /** 1898 * Returns 1899 * OM1-43: "Point Versus Interval" - creates it if necessary 1900 */ 1901 public CE getPointVersusInterval() { 1902 CE retVal = this.getTypedField(43, 0); 1903 return retVal; 1904 } 1905 1906 /** 1907 * Returns 1908 * OM1-43: "Point Versus Interval" - creates it if necessary 1909 */ 1910 public CE getOm143_PointVersusInterval() { 1911 CE retVal = this.getTypedField(43, 0); 1912 return retVal; 1913 } 1914 1915 1916 1917 /** 1918 * Returns 1919 * OM1-44: "Challenge Information" - creates it if necessary 1920 */ 1921 public TX getChallengeInformation() { 1922 TX retVal = this.getTypedField(44, 0); 1923 return retVal; 1924 } 1925 1926 /** 1927 * Returns 1928 * OM1-44: "Challenge Information" - creates it if necessary 1929 */ 1930 public TX getOm144_ChallengeInformation() { 1931 TX retVal = this.getTypedField(44, 0); 1932 return retVal; 1933 } 1934 1935 1936 1937 /** 1938 * Returns 1939 * OM1-45: "Relationship Modifier" - creates it if necessary 1940 */ 1941 public CE getRelationshipModifier() { 1942 CE retVal = this.getTypedField(45, 0); 1943 return retVal; 1944 } 1945 1946 /** 1947 * Returns 1948 * OM1-45: "Relationship Modifier" - creates it if necessary 1949 */ 1950 public CE getOm145_RelationshipModifier() { 1951 CE retVal = this.getTypedField(45, 0); 1952 return retVal; 1953 } 1954 1955 1956 1957 /** 1958 * Returns 1959 * OM1-46: "Target Anatomic Site Of Test" - creates it if necessary 1960 */ 1961 public CE getTargetAnatomicSiteOfTest() { 1962 CE retVal = this.getTypedField(46, 0); 1963 return retVal; 1964 } 1965 1966 /** 1967 * Returns 1968 * OM1-46: "Target Anatomic Site Of Test" - creates it if necessary 1969 */ 1970 public CE getOm146_TargetAnatomicSiteOfTest() { 1971 CE retVal = this.getTypedField(46, 0); 1972 return retVal; 1973 } 1974 1975 1976 1977 /** 1978 * Returns 1979 * OM1-47: "Modality Of Imaging Measurement" - creates it if necessary 1980 */ 1981 public CE getModalityOfImagingMeasurement() { 1982 CE retVal = this.getTypedField(47, 0); 1983 return retVal; 1984 } 1985 1986 /** 1987 * Returns 1988 * OM1-47: "Modality Of Imaging Measurement" - creates it if necessary 1989 */ 1990 public CE getOm147_ModalityOfImagingMeasurement() { 1991 CE retVal = this.getTypedField(47, 0); 1992 return retVal; 1993 } 1994 1995 1996 1997 1998 1999 /** {@inheritDoc} */ 2000 protected Type createNewTypeWithoutReflection(int field) { 2001 switch (field) { 2002 case 0: return new NM(getMessage()); 2003 case 1: return new CE(getMessage()); 2004 case 2: return new ID(getMessage(), new Integer( 125 )); 2005 case 3: return new ID(getMessage(), new Integer( 136 )); 2006 case 4: return new CE(getMessage()); 2007 case 5: return new TX(getMessage()); 2008 case 6: return new CE(getMessage()); 2009 case 7: return new ST(getMessage()); 2010 case 8: return new ST(getMessage()); 2011 case 9: return new ST(getMessage()); 2012 case 10: return new ST(getMessage()); 2013 case 11: return new ID(getMessage(), new Integer( 136 )); 2014 case 12: return new CE(getMessage()); 2015 case 13: return new CE(getMessage()); 2016 case 14: return new ID(getMessage(), new Integer( 136 )); 2017 case 15: return new CE(getMessage()); 2018 case 16: return new XTN(getMessage()); 2019 case 17: return new IS(getMessage(), new Integer( 174 )); 2020 case 18: return new CE(getMessage()); 2021 case 19: return new ST(getMessage()); 2022 case 20: return new TS(getMessage()); 2023 case 21: return new TS(getMessage()); 2024 case 22: return new NM(getMessage()); 2025 case 23: return new NM(getMessage()); 2026 case 24: return new ID(getMessage(), new Integer( 168 )); 2027 case 25: return new ID(getMessage(), new Integer( 169 )); 2028 case 26: return new CE(getMessage()); 2029 case 27: return new XAD(getMessage()); 2030 case 28: return new XTN(getMessage()); 2031 case 29: return new IS(getMessage(), new Integer( 177 )); 2032 case 30: return new CE(getMessage()); 2033 case 31: return new TX(getMessage()); 2034 case 32: return new CE(getMessage()); 2035 case 33: return new CE(getMessage()); 2036 case 34: return new TX(getMessage()); 2037 case 35: return new CE(getMessage()); 2038 case 36: return new TX(getMessage()); 2039 case 37: return new CE(getMessage()); 2040 case 38: return new TX(getMessage()); 2041 case 39: return new ST(getMessage()); 2042 case 40: return new TX(getMessage()); 2043 case 41: return new CE(getMessage()); 2044 case 42: return new CE(getMessage()); 2045 case 43: return new TX(getMessage()); 2046 case 44: return new CE(getMessage()); 2047 case 45: return new CE(getMessage()); 2048 case 46: return new CE(getMessage()); 2049 default: return null; 2050 } 2051 } 2052 2053 2054} 2055