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