View Javadoc
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.model.v231.group;
35  
36  import ca.uhn.hl7v2.model.v231.segment.*;
37  
38  import ca.uhn.hl7v2.HL7Exception;
39  import ca.uhn.hl7v2.parser.ModelClassFactory;
40  import ca.uhn.hl7v2.model.*;
41  
42  /**
43   * <p>Represents a ADR_A19_EVNPIDPD1NK1PV1PV2DB1OBXAL1DG1DRGPR1ROLGT1IN1IN2IN3ACCUB1UB2 group structure (a Group object).
44   * A Group is an ordered collection of message segments that can repeat together or be optionally in/excluded together.
45   * This Group contains the following elements:  
46   * </p>
47   * <ul>
48                           * <li>1: EVN (EVN - event type segment) <b>optional  </b></li>
49                           * <li>2: PID (PID - patient identification segment) <b>  </b></li>
50                           * <li>3: PD1 (PD1 - patient additional demographic segment) <b>optional  </b></li>
51                           * <li>4: NK1 (NK1 - next of kin / associated parties segment-) <b>optional repeating </b></li>
52                           * <li>5: PV1 (PV1 - patient visit segment-) <b>  </b></li>
53                           * <li>6: PV2 (PV2 - patient visit - additional information segment) <b>optional  </b></li>
54                           * <li>7: DB1 (DB1 - Disability segment) <b>optional repeating </b></li>
55                           * <li>8: OBX (OBX - observation/result segment) <b>optional repeating </b></li>
56                           * <li>9: AL1 (AL1 - patient allergy information segment) <b>optional repeating </b></li>
57                           * <li>10: DG1 (DG1 - diagnosis segment) <b>optional repeating </b></li>
58                           * <li>11: DRG (DRG - diagnosis related group segment) <b>optional  </b></li>
59                           * <li>12: ADR_A19_PR1ROL (a Group object) <b>optional repeating </b></li>
60                           * <li>13: GT1 (GT1 - guarantor segment) <b>optional repeating </b></li>
61                           * <li>14: ADR_A19_IN1IN2IN3 (a Group object) <b>optional repeating </b></li>
62                           * <li>15: ACC (ACC - accident segment) <b>optional  </b></li>
63                           * <li>16: UB1 (UB1 - UB82 data segment) <b>optional  </b></li>
64                           * <li>17: UB2 (UB2 - UB92 data segment) <b>optional  </b></li>
65   * </ul>
66   */
67  //@SuppressWarnings("unused")
68  public class ADR_A19_EVNPIDPD1NK1PV1PV2DB1OBXAL1DG1DRGPR1ROLGT1IN1IN2IN3ACCUB1UB2 extends AbstractGroup {
69  
70      /** 
71       * Creates a new ADR_A19_EVNPIDPD1NK1PV1PV2DB1OBXAL1DG1DRGPR1ROLGT1IN1IN2IN3ACCUB1UB2 group
72       */
73      public ADR_A19_EVNPIDPD1NK1PV1PV2DB1OBXAL1DG1DRGPR1ROLGT1IN1IN2IN3ACCUB1UB2(Group parent, ModelClassFactory factory) {
74         super(parent, factory);
75         init(factory);
76      }
77  
78      private void init(ModelClassFactory factory) {
79         try {
80                                    this.add(EVN.class, false, false, false);
81                                    this.add(PID.class, true, false, false);
82                                    this.add(PD1.class, false, false, false);
83                                    this.add(NK1.class, false, true, false);
84                                    this.add(PV1.class, true, false, false);
85                                    this.add(PV2.class, false, false, false);
86                                    this.add(DB1.class, false, true, false);
87                                    this.add(OBX.class, false, true, false);
88                                    this.add(AL1.class, false, true, false);
89                                    this.add(DG1.class, false, true, false);
90                                    this.add(DRG.class, false, false, false);
91                                    this.add(ADR_A19_PR1ROL.class, false, true, false);
92                                    this.add(GT1.class, false, true, false);
93                                    this.add(ADR_A19_IN1IN2IN3.class, false, true, false);
94                                    this.add(ACC.class, false, false, false);
95                                    this.add(UB1.class, false, false, false);
96                                    this.add(UB2.class, false, false, false);
97         } catch(HL7Exception e) {
98            log.error("Unexpected error creating ADR_A19_EVNPIDPD1NK1PV1PV2DB1OBXAL1DG1DRGPR1ROLGT1IN1IN2IN3ACCUB1UB2 - this is probably a bug in the source code generator.", e);
99         }
100     }
101 
102     /** 
103      * Returns "2.3.1"
104      */
105     public String getVersion() {
106        return "2.3.1";
107     }
108 
109 
110 
111     /**
112      * Returns
113      * EVN (EVN - event type segment) - creates it if necessary
114      */
115     public EVN getEVN() { 
116        EVN retVal = getTyped("EVN", EVN.class);
117        return retVal;
118     }
119 
120 
121 
122 
123     /**
124      * Returns
125      * PID (PID - patient identification segment) - creates it if necessary
126      */
127     public PID getPID() { 
128        PID retVal = getTyped("PID", PID.class);
129        return retVal;
130     }
131 
132 
133 
134 
135     /**
136      * Returns
137      * PD1 (PD1 - patient additional demographic segment) - creates it if necessary
138      */
139     public PD1 getPD1() { 
140        PD1 retVal = getTyped("PD1", PD1.class);
141        return retVal;
142     }
143 
144 
145 
146 
147     /**
148      * Returns
149      * the first repetition of 
150      * NK1 (NK1 - next of kin / associated parties segment-) - creates it if necessary
151      */
152     public NK1 getNK1() { 
153        NK1 retVal = getTyped("NK1", NK1.class);
154        return retVal;
155     }
156 
157 
158     /**
159      * Returns a specific repetition of
160      * NK1 (NK1 - next of kin / associated parties segment-) - creates it if necessary
161      *
162      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
163      * @throws HL7Exception if the repetition requested is more than one 
164      *     greater than the number of existing repetitions.
165      */
166     public NK1 getNK1(int rep) { 
167        NK1 retVal = getTyped("NK1", rep, NK1.class);
168        return retVal;
169     }
170 
171     /** 
172      * Returns the number of existing repetitions of NK1 
173      */ 
174     public int getNK1Reps() {  
175         return getReps("NK1");
176     } 
177 
178     /** 
179      * <p>
180      * Returns a non-modifiable List containing all current existing repetitions of NK1.
181      * <p>
182      * <p>
183      * Note that unlike {@link #getNK1()}, this method will not create any reps
184      * if none are already present, so an empty list may be returned.
185      * </p>
186      */ 
187     public java.util.List<NK1> getNK1All() throws HL7Exception {
188     	return getAllAsList("NK1", NK1.class);
189     } 
190 
191     /**
192      * Inserts a specific repetition of NK1 (NK1 - next of kin / associated parties segment-)
193      * @see AbstractGroup#insertRepetition(Structure, int) 
194      */
195     public void insertNK1(NK1 structure, int rep) throws HL7Exception { 
196        super.insertRepetition("NK1", structure, rep);
197     }
198 
199 
200     /**
201      * Inserts a specific repetition of NK1 (NK1 - next of kin / associated parties segment-)
202      * @see AbstractGroup#insertRepetition(Structure, int) 
203      */
204     public NK1 insertNK1(int rep) throws HL7Exception { 
205        return (NK1)super.insertRepetition("NK1", rep);
206     }
207 
208 
209     /**
210      * Removes a specific repetition of NK1 (NK1 - next of kin / associated parties segment-)
211      * @see AbstractGroup#removeRepetition(String, int) 
212      */
213     public NK1 removeNK1(int rep) throws HL7Exception { 
214        return (NK1)super.removeRepetition("NK1", rep);
215     }
216 
217 
218 
219     /**
220      * Returns
221      * PV1 (PV1 - patient visit segment-) - creates it if necessary
222      */
223     public PV1 getPV1() { 
224        PV1 retVal = getTyped("PV1", PV1.class);
225        return retVal;
226     }
227 
228 
229 
230 
231     /**
232      * Returns
233      * PV2 (PV2 - patient visit - additional information segment) - creates it if necessary
234      */
235     public PV2 getPV2() { 
236        PV2 retVal = getTyped("PV2", PV2.class);
237        return retVal;
238     }
239 
240 
241 
242 
243     /**
244      * Returns
245      * the first repetition of 
246      * DB1 (DB1 - Disability segment) - creates it if necessary
247      */
248     public DB1 getDB1() { 
249        DB1 retVal = getTyped("DB1", DB1.class);
250        return retVal;
251     }
252 
253 
254     /**
255      * Returns a specific repetition of
256      * DB1 (DB1 - Disability segment) - creates it if necessary
257      *
258      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
259      * @throws HL7Exception if the repetition requested is more than one 
260      *     greater than the number of existing repetitions.
261      */
262     public DB1 getDB1(int rep) { 
263        DB1 retVal = getTyped("DB1", rep, DB1.class);
264        return retVal;
265     }
266 
267     /** 
268      * Returns the number of existing repetitions of DB1 
269      */ 
270     public int getDB1Reps() {  
271         return getReps("DB1");
272     } 
273 
274     /** 
275      * <p>
276      * Returns a non-modifiable List containing all current existing repetitions of DB1.
277      * <p>
278      * <p>
279      * Note that unlike {@link #getDB1()}, this method will not create any reps
280      * if none are already present, so an empty list may be returned.
281      * </p>
282      */ 
283     public java.util.List<DB1> getDB1All() throws HL7Exception {
284     	return getAllAsList("DB1", DB1.class);
285     } 
286 
287     /**
288      * Inserts a specific repetition of DB1 (DB1 - Disability segment)
289      * @see AbstractGroup#insertRepetition(Structure, int) 
290      */
291     public void insertDB1(DB1 structure, int rep) throws HL7Exception { 
292        super.insertRepetition("DB1", structure, rep);
293     }
294 
295 
296     /**
297      * Inserts a specific repetition of DB1 (DB1 - Disability segment)
298      * @see AbstractGroup#insertRepetition(Structure, int) 
299      */
300     public DB1 insertDB1(int rep) throws HL7Exception { 
301        return (DB1)super.insertRepetition("DB1", rep);
302     }
303 
304 
305     /**
306      * Removes a specific repetition of DB1 (DB1 - Disability segment)
307      * @see AbstractGroup#removeRepetition(String, int) 
308      */
309     public DB1 removeDB1(int rep) throws HL7Exception { 
310        return (DB1)super.removeRepetition("DB1", rep);
311     }
312 
313 
314 
315     /**
316      * Returns
317      * the first repetition of 
318      * OBX (OBX - observation/result segment) - creates it if necessary
319      */
320     public OBX getOBX() { 
321        OBX retVal = getTyped("OBX", OBX.class);
322        return retVal;
323     }
324 
325 
326     /**
327      * Returns a specific repetition of
328      * OBX (OBX - observation/result segment) - creates it if necessary
329      *
330      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
331      * @throws HL7Exception if the repetition requested is more than one 
332      *     greater than the number of existing repetitions.
333      */
334     public OBX getOBX(int rep) { 
335        OBX retVal = getTyped("OBX", rep, OBX.class);
336        return retVal;
337     }
338 
339     /** 
340      * Returns the number of existing repetitions of OBX 
341      */ 
342     public int getOBXReps() {  
343         return getReps("OBX");
344     } 
345 
346     /** 
347      * <p>
348      * Returns a non-modifiable List containing all current existing repetitions of OBX.
349      * <p>
350      * <p>
351      * Note that unlike {@link #getOBX()}, this method will not create any reps
352      * if none are already present, so an empty list may be returned.
353      * </p>
354      */ 
355     public java.util.List<OBX> getOBXAll() throws HL7Exception {
356     	return getAllAsList("OBX", OBX.class);
357     } 
358 
359     /**
360      * Inserts a specific repetition of OBX (OBX - observation/result segment)
361      * @see AbstractGroup#insertRepetition(Structure, int) 
362      */
363     public void insertOBX(OBX structure, int rep) throws HL7Exception { 
364        super.insertRepetition("OBX", structure, rep);
365     }
366 
367 
368     /**
369      * Inserts a specific repetition of OBX (OBX - observation/result segment)
370      * @see AbstractGroup#insertRepetition(Structure, int) 
371      */
372     public OBX insertOBX(int rep) throws HL7Exception { 
373        return (OBX)super.insertRepetition("OBX", rep);
374     }
375 
376 
377     /**
378      * Removes a specific repetition of OBX (OBX - observation/result segment)
379      * @see AbstractGroup#removeRepetition(String, int) 
380      */
381     public OBX removeOBX(int rep) throws HL7Exception { 
382        return (OBX)super.removeRepetition("OBX", rep);
383     }
384 
385 
386 
387     /**
388      * Returns
389      * the first repetition of 
390      * AL1 (AL1 - patient allergy information segment) - creates it if necessary
391      */
392     public AL1 getAL1() { 
393        AL1 retVal = getTyped("AL1", AL1.class);
394        return retVal;
395     }
396 
397 
398     /**
399      * Returns a specific repetition of
400      * AL1 (AL1 - patient allergy information segment) - creates it if necessary
401      *
402      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
403      * @throws HL7Exception if the repetition requested is more than one 
404      *     greater than the number of existing repetitions.
405      */
406     public AL1 getAL1(int rep) { 
407        AL1 retVal = getTyped("AL1", rep, AL1.class);
408        return retVal;
409     }
410 
411     /** 
412      * Returns the number of existing repetitions of AL1 
413      */ 
414     public int getAL1Reps() {  
415         return getReps("AL1");
416     } 
417 
418     /** 
419      * <p>
420      * Returns a non-modifiable List containing all current existing repetitions of AL1.
421      * <p>
422      * <p>
423      * Note that unlike {@link #getAL1()}, this method will not create any reps
424      * if none are already present, so an empty list may be returned.
425      * </p>
426      */ 
427     public java.util.List<AL1> getAL1All() throws HL7Exception {
428     	return getAllAsList("AL1", AL1.class);
429     } 
430 
431     /**
432      * Inserts a specific repetition of AL1 (AL1 - patient allergy information segment)
433      * @see AbstractGroup#insertRepetition(Structure, int) 
434      */
435     public void insertAL1(AL1 structure, int rep) throws HL7Exception { 
436        super.insertRepetition("AL1", structure, rep);
437     }
438 
439 
440     /**
441      * Inserts a specific repetition of AL1 (AL1 - patient allergy information segment)
442      * @see AbstractGroup#insertRepetition(Structure, int) 
443      */
444     public AL1 insertAL1(int rep) throws HL7Exception { 
445        return (AL1)super.insertRepetition("AL1", rep);
446     }
447 
448 
449     /**
450      * Removes a specific repetition of AL1 (AL1 - patient allergy information segment)
451      * @see AbstractGroup#removeRepetition(String, int) 
452      */
453     public AL1 removeAL1(int rep) throws HL7Exception { 
454        return (AL1)super.removeRepetition("AL1", rep);
455     }
456 
457 
458 
459     /**
460      * Returns
461      * the first repetition of 
462      * DG1 (DG1 - diagnosis segment) - creates it if necessary
463      */
464     public DG1 getDG1() { 
465        DG1 retVal = getTyped("DG1", DG1.class);
466        return retVal;
467     }
468 
469 
470     /**
471      * Returns a specific repetition of
472      * DG1 (DG1 - diagnosis segment) - creates it if necessary
473      *
474      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
475      * @throws HL7Exception if the repetition requested is more than one 
476      *     greater than the number of existing repetitions.
477      */
478     public DG1 getDG1(int rep) { 
479        DG1 retVal = getTyped("DG1", rep, DG1.class);
480        return retVal;
481     }
482 
483     /** 
484      * Returns the number of existing repetitions of DG1 
485      */ 
486     public int getDG1Reps() {  
487         return getReps("DG1");
488     } 
489 
490     /** 
491      * <p>
492      * Returns a non-modifiable List containing all current existing repetitions of DG1.
493      * <p>
494      * <p>
495      * Note that unlike {@link #getDG1()}, this method will not create any reps
496      * if none are already present, so an empty list may be returned.
497      * </p>
498      */ 
499     public java.util.List<DG1> getDG1All() throws HL7Exception {
500     	return getAllAsList("DG1", DG1.class);
501     } 
502 
503     /**
504      * Inserts a specific repetition of DG1 (DG1 - diagnosis segment)
505      * @see AbstractGroup#insertRepetition(Structure, int) 
506      */
507     public void insertDG1(DG1 structure, int rep) throws HL7Exception { 
508        super.insertRepetition("DG1", structure, rep);
509     }
510 
511 
512     /**
513      * Inserts a specific repetition of DG1 (DG1 - diagnosis segment)
514      * @see AbstractGroup#insertRepetition(Structure, int) 
515      */
516     public DG1 insertDG1(int rep) throws HL7Exception { 
517        return (DG1)super.insertRepetition("DG1", rep);
518     }
519 
520 
521     /**
522      * Removes a specific repetition of DG1 (DG1 - diagnosis segment)
523      * @see AbstractGroup#removeRepetition(String, int) 
524      */
525     public DG1 removeDG1(int rep) throws HL7Exception { 
526        return (DG1)super.removeRepetition("DG1", rep);
527     }
528 
529 
530 
531     /**
532      * Returns
533      * DRG (DRG - diagnosis related group segment) - creates it if necessary
534      */
535     public DRG getDRG() { 
536        DRG retVal = getTyped("DRG", DRG.class);
537        return retVal;
538     }
539 
540 
541 
542 
543     /**
544      * Returns
545      * the first repetition of 
546      * PR1ROL (a Group object) - creates it if necessary
547      */
548     public ADR_A19_PR1ROL getPR1ROL() { 
549        ADR_A19_PR1ROL retVal = getTyped("PR1ROL", ADR_A19_PR1ROL.class);
550        return retVal;
551     }
552 
553 
554     /**
555      * Returns a specific repetition of
556      * PR1ROL (a Group object) - creates it if necessary
557      *
558      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
559      * @throws HL7Exception if the repetition requested is more than one 
560      *     greater than the number of existing repetitions.
561      */
562     public ADR_A19_PR1ROL getPR1ROL(int rep) { 
563        ADR_A19_PR1ROL retVal = getTyped("PR1ROL", rep, ADR_A19_PR1ROL.class);
564        return retVal;
565     }
566 
567     /** 
568      * Returns the number of existing repetitions of PR1ROL 
569      */ 
570     public int getPR1ROLReps() {  
571         return getReps("PR1ROL");
572     } 
573 
574     /** 
575      * <p>
576      * Returns a non-modifiable List containing all current existing repetitions of PR1ROL.
577      * <p>
578      * <p>
579      * Note that unlike {@link #getPR1ROL()}, this method will not create any reps
580      * if none are already present, so an empty list may be returned.
581      * </p>
582      */ 
583     public java.util.List<ADR_A19_PR1ROL> getPR1ROLAll() throws HL7Exception {
584     	return getAllAsList("PR1ROL", ADR_A19_PR1ROL.class);
585     } 
586 
587     /**
588      * Inserts a specific repetition of PR1ROL (a Group object)
589      * @see AbstractGroup#insertRepetition(Structure, int) 
590      */
591     public void insertPR1ROL(ADR_A19_PR1ROL structure, int rep) throws HL7Exception { 
592        super.insertRepetition("PR1ROL", structure, rep);
593     }
594 
595 
596     /**
597      * Inserts a specific repetition of PR1ROL (a Group object)
598      * @see AbstractGroup#insertRepetition(Structure, int) 
599      */
600     public ADR_A19_PR1ROL insertPR1ROL(int rep) throws HL7Exception { 
601        return (ADR_A19_PR1ROL)super.insertRepetition("PR1ROL", rep);
602     }
603 
604 
605     /**
606      * Removes a specific repetition of PR1ROL (a Group object)
607      * @see AbstractGroup#removeRepetition(String, int) 
608      */
609     public ADR_A19_PR1ROL removePR1ROL(int rep) throws HL7Exception { 
610        return (ADR_A19_PR1ROL)super.removeRepetition("PR1ROL", rep);
611     }
612 
613 
614 
615     /**
616      * Returns
617      * the first repetition of 
618      * GT1 (GT1 - guarantor segment) - creates it if necessary
619      */
620     public GT1 getGT1() { 
621        GT1 retVal = getTyped("GT1", GT1.class);
622        return retVal;
623     }
624 
625 
626     /**
627      * Returns a specific repetition of
628      * GT1 (GT1 - guarantor segment) - creates it if necessary
629      *
630      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
631      * @throws HL7Exception if the repetition requested is more than one 
632      *     greater than the number of existing repetitions.
633      */
634     public GT1 getGT1(int rep) { 
635        GT1 retVal = getTyped("GT1", rep, GT1.class);
636        return retVal;
637     }
638 
639     /** 
640      * Returns the number of existing repetitions of GT1 
641      */ 
642     public int getGT1Reps() {  
643         return getReps("GT1");
644     } 
645 
646     /** 
647      * <p>
648      * Returns a non-modifiable List containing all current existing repetitions of GT1.
649      * <p>
650      * <p>
651      * Note that unlike {@link #getGT1()}, this method will not create any reps
652      * if none are already present, so an empty list may be returned.
653      * </p>
654      */ 
655     public java.util.List<GT1> getGT1All() throws HL7Exception {
656     	return getAllAsList("GT1", GT1.class);
657     } 
658 
659     /**
660      * Inserts a specific repetition of GT1 (GT1 - guarantor segment)
661      * @see AbstractGroup#insertRepetition(Structure, int) 
662      */
663     public void insertGT1(GT1 structure, int rep) throws HL7Exception { 
664        super.insertRepetition("GT1", structure, rep);
665     }
666 
667 
668     /**
669      * Inserts a specific repetition of GT1 (GT1 - guarantor segment)
670      * @see AbstractGroup#insertRepetition(Structure, int) 
671      */
672     public GT1 insertGT1(int rep) throws HL7Exception { 
673        return (GT1)super.insertRepetition("GT1", rep);
674     }
675 
676 
677     /**
678      * Removes a specific repetition of GT1 (GT1 - guarantor segment)
679      * @see AbstractGroup#removeRepetition(String, int) 
680      */
681     public GT1 removeGT1(int rep) throws HL7Exception { 
682        return (GT1)super.removeRepetition("GT1", rep);
683     }
684 
685 
686 
687     /**
688      * Returns
689      * the first repetition of 
690      * IN1IN2IN3 (a Group object) - creates it if necessary
691      */
692     public ADR_A19_IN1IN2IN3 getIN1IN2IN3() { 
693        ADR_A19_IN1IN2IN3 retVal = getTyped("IN1IN2IN3", ADR_A19_IN1IN2IN3.class);
694        return retVal;
695     }
696 
697 
698     /**
699      * Returns a specific repetition of
700      * IN1IN2IN3 (a Group object) - creates it if necessary
701      *
702      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
703      * @throws HL7Exception if the repetition requested is more than one 
704      *     greater than the number of existing repetitions.
705      */
706     public ADR_A19_IN1IN2IN3 getIN1IN2IN3(int rep) { 
707        ADR_A19_IN1IN2IN3 retVal = getTyped("IN1IN2IN3", rep, ADR_A19_IN1IN2IN3.class);
708        return retVal;
709     }
710 
711     /** 
712      * Returns the number of existing repetitions of IN1IN2IN3 
713      */ 
714     public int getIN1IN2IN3Reps() {  
715         return getReps("IN1IN2IN3");
716     } 
717 
718     /** 
719      * <p>
720      * Returns a non-modifiable List containing all current existing repetitions of IN1IN2IN3.
721      * <p>
722      * <p>
723      * Note that unlike {@link #getIN1IN2IN3()}, this method will not create any reps
724      * if none are already present, so an empty list may be returned.
725      * </p>
726      */ 
727     public java.util.List<ADR_A19_IN1IN2IN3> getIN1IN2IN3All() throws HL7Exception {
728     	return getAllAsList("IN1IN2IN3", ADR_A19_IN1IN2IN3.class);
729     } 
730 
731     /**
732      * Inserts a specific repetition of IN1IN2IN3 (a Group object)
733      * @see AbstractGroup#insertRepetition(Structure, int) 
734      */
735     public void insertIN1IN2IN3(ADR_A19_IN1IN2IN3 structure, int rep) throws HL7Exception { 
736        super.insertRepetition("IN1IN2IN3", structure, rep);
737     }
738 
739 
740     /**
741      * Inserts a specific repetition of IN1IN2IN3 (a Group object)
742      * @see AbstractGroup#insertRepetition(Structure, int) 
743      */
744     public ADR_A19_IN1IN2IN3 insertIN1IN2IN3(int rep) throws HL7Exception { 
745        return (ADR_A19_IN1IN2IN3)super.insertRepetition("IN1IN2IN3", rep);
746     }
747 
748 
749     /**
750      * Removes a specific repetition of IN1IN2IN3 (a Group object)
751      * @see AbstractGroup#removeRepetition(String, int) 
752      */
753     public ADR_A19_IN1IN2IN3 removeIN1IN2IN3(int rep) throws HL7Exception { 
754        return (ADR_A19_IN1IN2IN3)super.removeRepetition("IN1IN2IN3", rep);
755     }
756 
757 
758 
759     /**
760      * Returns
761      * ACC (ACC - accident segment) - creates it if necessary
762      */
763     public ACC getACC() { 
764        ACC retVal = getTyped("ACC", ACC.class);
765        return retVal;
766     }
767 
768 
769 
770 
771     /**
772      * Returns
773      * UB1 (UB1 - UB82 data segment) - creates it if necessary
774      */
775     public UB1 getUB1() { 
776        UB1 retVal = getTyped("UB1", UB1.class);
777        return retVal;
778     }
779 
780 
781 
782 
783     /**
784      * Returns
785      * UB2 (UB2 - UB92 data segment) - creates it if necessary
786      */
787     public UB2 getUB2() { 
788        UB2 retVal = getTyped("UB2", UB2.class);
789        return retVal;
790     }
791 
792 
793 
794 
795 }
796