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