Source code

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.v21.segment;
035
036// import ca.uhn.hl7v2.model.v21.group.*;
037import ca.uhn.hl7v2.model.v21.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 PID message segment (PATIENT IDENTIFICATION). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>PID-1: SET ID - PATIENT ID (SI) <b>optional </b>
053     * <li>PID-2: PATIENT ID EXTERNAL (EXTERNAL ID) (CK) <b>optional </b>
054     * <li>PID-3: PATIENT ID INTERNAL (INTERNAL ID) (CK) <b> </b>
055     * <li>PID-4: ALTERNATE PATIENT ID (ST) <b>optional </b>
056     * <li>PID-5: PATIENT NAME (PN) <b> </b>
057     * <li>PID-6: MOTHER'S MAIDEN NAME (ST) <b>optional </b>
058     * <li>PID-7: DATE OF BIRTH (DT) <b>optional </b>
059     * <li>PID-8: SEX (ID) <b>optional </b>
060     * <li>PID-9: PATIENT ALIAS (PN) <b>optional repeating</b>
061     * <li>PID-10: ETHNIC GROUP (ID) <b>optional </b>
062     * <li>PID-11: PATIENT ADDRESS (AD) <b>optional </b>
063     * <li>PID-12: COUNTY CODE (ID) <b>optional </b>
064     * <li>PID-13: PHONE NUMBER - HOME (TN) <b>optional repeating</b>
065     * <li>PID-14: PHONE NUMBER - BUSINESS (TN) <b>optional repeating</b>
066     * <li>PID-15: LANGUAGE - PATIENT (ST) <b>optional </b>
067     * <li>PID-16: MARITAL STATUS (ID) <b>optional </b>
068     * <li>PID-17: RELIGION (ID) <b>optional </b>
069     * <li>PID-18: PATIENT ACCOUNT NUMBER (CK) <b>optional </b>
070     * <li>PID-19: SSN NUMBER - PATIENT (ST) <b>optional </b>
071     * <li>PID-20: DRIVER'S LIC NUM - PATIENT (CM) <b>optional </b>
072 * </ul>
073 */
074@SuppressWarnings("unused")
075public class PID extends AbstractSegment {
076
077    /** 
078     * Creates a new PID segment
079     */
080    public PID(Group parent, ModelClassFactory factory) {
081       super(parent, factory);
082       init(factory);
083    }
084
085    private void init(ModelClassFactory factory) {
086       try {
087                                  this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "SET ID - PATIENT ID");
088                                  this.add(CK.class, false, 1, 16, new Object[]{ getMessage() }, "PATIENT ID EXTERNAL (EXTERNAL ID)");
089                                  this.add(CK.class, true, 1, 16, new Object[]{ getMessage() }, "PATIENT ID INTERNAL (INTERNAL ID)");
090                                  this.add(ST.class, false, 1, 12, new Object[]{ getMessage() }, "ALTERNATE PATIENT ID");
091                                  this.add(PN.class, true, 1, 48, new Object[]{ getMessage() }, "PATIENT NAME");
092                                  this.add(ST.class, false, 1, 30, new Object[]{ getMessage() }, "MOTHER'S MAIDEN NAME");
093                                  this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "DATE OF BIRTH");
094                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "SEX");
095                                  this.add(PN.class, false, 0, 48, new Object[]{ getMessage() }, "PATIENT ALIAS");
096                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(5) }, "ETHNIC GROUP");
097                                  this.add(AD.class, false, 1, 106, new Object[]{ getMessage() }, "PATIENT ADDRESS");
098                                              this.add(ID.class, false, 1, 4, new Object[]{ getMessage(), new Integer(0) }, "COUNTY CODE");
099                                  this.add(TN.class, false, 3, 40, new Object[]{ getMessage() }, "PHONE NUMBER - HOME");
100                                  this.add(TN.class, false, 3, 40, new Object[]{ getMessage() }, "PHONE NUMBER - BUSINESS");
101                                  this.add(ST.class, false, 1, 25, new Object[]{ getMessage() }, "LANGUAGE - PATIENT");
102                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(2) }, "MARITAL STATUS");
103                                              this.add(ID.class, false, 1, 3, new Object[]{ getMessage(), new Integer(6) }, "RELIGION");
104                                  this.add(CK.class, false, 1, 20, new Object[]{ getMessage() }, "PATIENT ACCOUNT NUMBER");
105                                  this.add(ST.class, false, 1, 16, new Object[]{ getMessage() }, "SSN NUMBER - PATIENT");
106                                  this.add(CM.class, false, 1, 25, new Object[]{ getMessage() }, "DRIVER'S LIC NUM - PATIENT");
107       } catch(HL7Exception e) {
108          log.error("Unexpected error creating PID - this is probably a bug in the source code generator.", e);
109       }
110    }
111
112
113
114    /**
115     * Returns
116     * PID-1: "SET ID - PATIENT ID" - creates it if necessary
117     */
118    public SI getSETIDPATIENTID() { 
119                SI retVal = this.getTypedField(1, 0);
120                return retVal;
121    }
122    
123    /**
124     * Returns
125     * PID-1: "SET ID - PATIENT ID" - creates it if necessary
126     */
127    public SI getPid1_SETIDPATIENTID() { 
128                SI retVal = this.getTypedField(1, 0);
129                return retVal;
130    }
131
132
133
134    /**
135     * Returns
136     * PID-2: "PATIENT ID EXTERNAL (EXTERNAL ID)" - creates it if necessary
137     */
138    public CK getPATIENTIDEXTERNALEXTERNALID() { 
139                CK retVal = this.getTypedField(2, 0);
140                return retVal;
141    }
142    
143    /**
144     * Returns
145     * PID-2: "PATIENT ID EXTERNAL (EXTERNAL ID)" - creates it if necessary
146     */
147    public CK getPid2_PATIENTIDEXTERNALEXTERNALID() { 
148                CK retVal = this.getTypedField(2, 0);
149                return retVal;
150    }
151
152
153
154    /**
155     * Returns
156     * PID-3: "PATIENT ID INTERNAL (INTERNAL ID)" - creates it if necessary
157     */
158    public CK getPATIENTIDINTERNALINTERNALID() { 
159                CK retVal = this.getTypedField(3, 0);
160                return retVal;
161    }
162    
163    /**
164     * Returns
165     * PID-3: "PATIENT ID INTERNAL (INTERNAL ID)" - creates it if necessary
166     */
167    public CK getPid3_PATIENTIDINTERNALINTERNALID() { 
168                CK retVal = this.getTypedField(3, 0);
169                return retVal;
170    }
171
172
173
174    /**
175     * Returns
176     * PID-4: "ALTERNATE PATIENT ID" - creates it if necessary
177     */
178    public ST getALTERNATEPATIENTID() { 
179                ST retVal = this.getTypedField(4, 0);
180                return retVal;
181    }
182    
183    /**
184     * Returns
185     * PID-4: "ALTERNATE PATIENT ID" - creates it if necessary
186     */
187    public ST getPid4_ALTERNATEPATIENTID() { 
188                ST retVal = this.getTypedField(4, 0);
189                return retVal;
190    }
191
192
193
194    /**
195     * Returns
196     * PID-5: "PATIENT NAME" - creates it if necessary
197     */
198    public PN getPATIENTNAME() { 
199                PN retVal = this.getTypedField(5, 0);
200                return retVal;
201    }
202    
203    /**
204     * Returns
205     * PID-5: "PATIENT NAME" - creates it if necessary
206     */
207    public PN getPid5_PATIENTNAME() { 
208                PN retVal = this.getTypedField(5, 0);
209                return retVal;
210    }
211
212
213
214    /**
215     * Returns
216     * PID-6: "MOTHER'S MAIDEN NAME" - creates it if necessary
217     */
218    public ST getMOTHERSMAIDENNAME() { 
219                ST retVal = this.getTypedField(6, 0);
220                return retVal;
221    }
222    
223    /**
224     * Returns
225     * PID-6: "MOTHER'S MAIDEN NAME" - creates it if necessary
226     */
227    public ST getPid6_MOTHERSMAIDENNAME() { 
228                ST retVal = this.getTypedField(6, 0);
229                return retVal;
230    }
231
232
233
234    /**
235     * Returns
236     * PID-7: "DATE OF BIRTH" - creates it if necessary
237     */
238    public DT getDATEOFBIRTH() { 
239                DT retVal = this.getTypedField(7, 0);
240                return retVal;
241    }
242    
243    /**
244     * Returns
245     * PID-7: "DATE OF BIRTH" - creates it if necessary
246     */
247    public DT getPid7_DATEOFBIRTH() { 
248                DT retVal = this.getTypedField(7, 0);
249                return retVal;
250    }
251
252
253
254    /**
255     * Returns
256     * PID-8: "SEX" - creates it if necessary
257     */
258    public ID getSEX() { 
259                ID retVal = this.getTypedField(8, 0);
260                return retVal;
261    }
262    
263    /**
264     * Returns
265     * PID-8: "SEX" - creates it if necessary
266     */
267    public ID getPid8_SEX() { 
268                ID retVal = this.getTypedField(8, 0);
269                return retVal;
270    }
271
272
273    /**
274     * Returns all repetitions of PATIENT ALIAS (PID-9).
275     */
276    public PN[] getPATIENTALIAS() {
277        PN[] retVal = this.getTypedField(9, new PN[0]);
278        return retVal;
279    }
280
281
282    /**
283     * Returns all repetitions of PATIENT ALIAS (PID-9).
284     */
285    public PN[] getPid9_PATIENTALIAS() {
286        PN[] retVal = this.getTypedField(9, new PN[0]);
287        return retVal;
288    }
289
290
291    /**
292     * Returns a count of the current number of repetitions of PATIENT ALIAS (PID-9).
293     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
294     * it will return zero.
295     */
296    public int getPATIENTALIASReps() {
297        return this.getReps(9);
298    }
299
300
301    /**
302     * Returns a specific repetition of
303     * PID-9: "PATIENT ALIAS" - creates it if necessary
304     *
305     * @param rep The repetition index (0-indexed)
306     */
307    public PN getPATIENTALIAS(int rep) { 
308                PN retVal = this.getTypedField(9, rep);
309                return retVal;
310    }
311
312    /**
313     * Returns a specific repetition of
314     * PID-9: "PATIENT ALIAS" - creates it if necessary
315     *
316     * @param rep The repetition index (0-indexed)
317     */
318    public PN getPid9_PATIENTALIAS(int rep) { 
319                PN retVal = this.getTypedField(9, rep);
320                return retVal;
321    }
322
323    /**
324     * Returns a count of the current number of repetitions of PATIENT ALIAS (PID-9).
325     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
326     * it will return zero.
327     */
328    public int getPid9_PATIENTALIASReps() {
329        return this.getReps(9);
330    }
331
332
333    /**
334     * Inserts a repetition of
335     * PID-9: "PATIENT ALIAS" at a specific index
336     *
337     * @param rep The repetition index (0-indexed)
338     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
339     */
340    public PN insertPATIENTALIAS(int rep) throws HL7Exception { 
341        return (PN) super.insertRepetition(9, rep);
342    }
343
344
345    /**
346     * Inserts a repetition of
347     * PID-9: "PATIENT ALIAS" at a specific index
348     *
349     * @param rep The repetition index (0-indexed)
350     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
351     */
352    public PN insertPid9_PATIENTALIAS(int rep) throws HL7Exception { 
353        return (PN) super.insertRepetition(9, rep);
354    }
355
356
357    /**
358     * Removes a repetition of
359     * PID-9: "PATIENT ALIAS" at a specific index
360     *
361     * @param rep The repetition index (0-indexed)
362     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
363     */
364    public PN removePATIENTALIAS(int rep) throws HL7Exception { 
365        return (PN) super.removeRepetition(9, rep);
366    }
367
368
369    /**
370     * Removes a repetition of
371     * PID-9: "PATIENT ALIAS" at a specific index
372     *
373     * @param rep The repetition index (0-indexed)
374     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
375     */
376    public PN removePid9_PATIENTALIAS(int rep) throws HL7Exception { 
377        return (PN) super.removeRepetition(9, rep);
378    }
379
380
381
382
383    /**
384     * Returns
385     * PID-10: "ETHNIC GROUP" - creates it if necessary
386     */
387    public ID getETHNICGROUP() { 
388                ID retVal = this.getTypedField(10, 0);
389                return retVal;
390    }
391    
392    /**
393     * Returns
394     * PID-10: "ETHNIC GROUP" - creates it if necessary
395     */
396    public ID getPid10_ETHNICGROUP() { 
397                ID retVal = this.getTypedField(10, 0);
398                return retVal;
399    }
400
401
402
403    /**
404     * Returns
405     * PID-11: "PATIENT ADDRESS" - creates it if necessary
406     */
407    public AD getPATIENTADDRESS() { 
408                AD retVal = this.getTypedField(11, 0);
409                return retVal;
410    }
411    
412    /**
413     * Returns
414     * PID-11: "PATIENT ADDRESS" - creates it if necessary
415     */
416    public AD getPid11_PATIENTADDRESS() { 
417                AD retVal = this.getTypedField(11, 0);
418                return retVal;
419    }
420
421
422
423    /**
424     * Returns
425     * PID-12: "COUNTY CODE" - creates it if necessary
426     */
427    public ID getCOUNTYCODE() { 
428                ID retVal = this.getTypedField(12, 0);
429                return retVal;
430    }
431    
432    /**
433     * Returns
434     * PID-12: "COUNTY CODE" - creates it if necessary
435     */
436    public ID getPid12_COUNTYCODE() { 
437                ID retVal = this.getTypedField(12, 0);
438                return retVal;
439    }
440
441
442    /**
443     * Returns all repetitions of PHONE NUMBER - HOME (PID-13).
444     */
445    public TN[] getPHONENUMBERHOME() {
446        TN[] retVal = this.getTypedField(13, new TN[0]);
447        return retVal;
448    }
449
450
451    /**
452     * Returns all repetitions of PHONE NUMBER - HOME (PID-13).
453     */
454    public TN[] getPid13_PHONENUMBERHOME() {
455        TN[] retVal = this.getTypedField(13, new TN[0]);
456        return retVal;
457    }
458
459
460    /**
461     * Returns a count of the current number of repetitions of PHONE NUMBER - HOME (PID-13).
462     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
463     * it will return zero.
464     */
465    public int getPHONENUMBERHOMEReps() {
466        return this.getReps(13);
467    }
468
469
470    /**
471     * Returns a specific repetition of
472     * PID-13: "PHONE NUMBER - HOME" - creates it if necessary
473     *
474     * @param rep The repetition index (0-indexed)
475     */
476    public TN getPHONENUMBERHOME(int rep) { 
477                TN retVal = this.getTypedField(13, rep);
478                return retVal;
479    }
480
481    /**
482     * Returns a specific repetition of
483     * PID-13: "PHONE NUMBER - HOME" - creates it if necessary
484     *
485     * @param rep The repetition index (0-indexed)
486     */
487    public TN getPid13_PHONENUMBERHOME(int rep) { 
488                TN retVal = this.getTypedField(13, rep);
489                return retVal;
490    }
491
492    /**
493     * Returns a count of the current number of repetitions of PHONE NUMBER - HOME (PID-13).
494     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
495     * it will return zero.
496     */
497    public int getPid13_PHONENUMBERHOMEReps() {
498        return this.getReps(13);
499    }
500
501
502    /**
503     * Inserts a repetition of
504     * PID-13: "PHONE NUMBER - HOME" at a specific index
505     *
506     * @param rep The repetition index (0-indexed)
507     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
508     */
509    public TN insertPHONENUMBERHOME(int rep) throws HL7Exception { 
510        return (TN) super.insertRepetition(13, rep);
511    }
512
513
514    /**
515     * Inserts a repetition of
516     * PID-13: "PHONE NUMBER - HOME" at a specific index
517     *
518     * @param rep The repetition index (0-indexed)
519     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
520     */
521    public TN insertPid13_PHONENUMBERHOME(int rep) throws HL7Exception { 
522        return (TN) super.insertRepetition(13, rep);
523    }
524
525
526    /**
527     * Removes a repetition of
528     * PID-13: "PHONE NUMBER - HOME" at a specific index
529     *
530     * @param rep The repetition index (0-indexed)
531     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
532     */
533    public TN removePHONENUMBERHOME(int rep) throws HL7Exception { 
534        return (TN) super.removeRepetition(13, rep);
535    }
536
537
538    /**
539     * Removes a repetition of
540     * PID-13: "PHONE NUMBER - HOME" at a specific index
541     *
542     * @param rep The repetition index (0-indexed)
543     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
544     */
545    public TN removePid13_PHONENUMBERHOME(int rep) throws HL7Exception { 
546        return (TN) super.removeRepetition(13, rep);
547    }
548
549
550
551    /**
552     * Returns all repetitions of PHONE NUMBER - BUSINESS (PID-14).
553     */
554    public TN[] getPHONENUMBERBUSINESS() {
555        TN[] retVal = this.getTypedField(14, new TN[0]);
556        return retVal;
557    }
558
559
560    /**
561     * Returns all repetitions of PHONE NUMBER - BUSINESS (PID-14).
562     */
563    public TN[] getPid14_PHONENUMBERBUSINESS() {
564        TN[] retVal = this.getTypedField(14, new TN[0]);
565        return retVal;
566    }
567
568
569    /**
570     * Returns a count of the current number of repetitions of PHONE NUMBER - BUSINESS (PID-14).
571     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
572     * it will return zero.
573     */
574    public int getPHONENUMBERBUSINESSReps() {
575        return this.getReps(14);
576    }
577
578
579    /**
580     * Returns a specific repetition of
581     * PID-14: "PHONE NUMBER - BUSINESS" - creates it if necessary
582     *
583     * @param rep The repetition index (0-indexed)
584     */
585    public TN getPHONENUMBERBUSINESS(int rep) { 
586                TN retVal = this.getTypedField(14, rep);
587                return retVal;
588    }
589
590    /**
591     * Returns a specific repetition of
592     * PID-14: "PHONE NUMBER - BUSINESS" - creates it if necessary
593     *
594     * @param rep The repetition index (0-indexed)
595     */
596    public TN getPid14_PHONENUMBERBUSINESS(int rep) { 
597                TN retVal = this.getTypedField(14, rep);
598                return retVal;
599    }
600
601    /**
602     * Returns a count of the current number of repetitions of PHONE NUMBER - BUSINESS (PID-14).
603     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
604     * it will return zero.
605     */
606    public int getPid14_PHONENUMBERBUSINESSReps() {
607        return this.getReps(14);
608    }
609
610
611    /**
612     * Inserts a repetition of
613     * PID-14: "PHONE NUMBER - BUSINESS" at a specific index
614     *
615     * @param rep The repetition index (0-indexed)
616     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
617     */
618    public TN insertPHONENUMBERBUSINESS(int rep) throws HL7Exception { 
619        return (TN) super.insertRepetition(14, rep);
620    }
621
622
623    /**
624     * Inserts a repetition of
625     * PID-14: "PHONE NUMBER - BUSINESS" at a specific index
626     *
627     * @param rep The repetition index (0-indexed)
628     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
629     */
630    public TN insertPid14_PHONENUMBERBUSINESS(int rep) throws HL7Exception { 
631        return (TN) super.insertRepetition(14, rep);
632    }
633
634
635    /**
636     * Removes a repetition of
637     * PID-14: "PHONE NUMBER - BUSINESS" at a specific index
638     *
639     * @param rep The repetition index (0-indexed)
640     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
641     */
642    public TN removePHONENUMBERBUSINESS(int rep) throws HL7Exception { 
643        return (TN) super.removeRepetition(14, rep);
644    }
645
646
647    /**
648     * Removes a repetition of
649     * PID-14: "PHONE NUMBER - BUSINESS" at a specific index
650     *
651     * @param rep The repetition index (0-indexed)
652     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
653     */
654    public TN removePid14_PHONENUMBERBUSINESS(int rep) throws HL7Exception { 
655        return (TN) super.removeRepetition(14, rep);
656    }
657
658
659
660
661    /**
662     * Returns
663     * PID-15: "LANGUAGE - PATIENT" - creates it if necessary
664     */
665    public ST getLANGUAGEPATIENT() { 
666                ST retVal = this.getTypedField(15, 0);
667                return retVal;
668    }
669    
670    /**
671     * Returns
672     * PID-15: "LANGUAGE - PATIENT" - creates it if necessary
673     */
674    public ST getPid15_LANGUAGEPATIENT() { 
675                ST retVal = this.getTypedField(15, 0);
676                return retVal;
677    }
678
679
680
681    /**
682     * Returns
683     * PID-16: "MARITAL STATUS" - creates it if necessary
684     */
685    public ID getMARITALSTATUS() { 
686                ID retVal = this.getTypedField(16, 0);
687                return retVal;
688    }
689    
690    /**
691     * Returns
692     * PID-16: "MARITAL STATUS" - creates it if necessary
693     */
694    public ID getPid16_MARITALSTATUS() { 
695                ID retVal = this.getTypedField(16, 0);
696                return retVal;
697    }
698
699
700
701    /**
702     * Returns
703     * PID-17: "RELIGION" - creates it if necessary
704     */
705    public ID getRELIGION() { 
706                ID retVal = this.getTypedField(17, 0);
707                return retVal;
708    }
709    
710    /**
711     * Returns
712     * PID-17: "RELIGION" - creates it if necessary
713     */
714    public ID getPid17_RELIGION() { 
715                ID retVal = this.getTypedField(17, 0);
716                return retVal;
717    }
718
719
720
721    /**
722     * Returns
723     * PID-18: "PATIENT ACCOUNT NUMBER" - creates it if necessary
724     */
725    public CK getPATIENTACCOUNTNUMBER() { 
726                CK retVal = this.getTypedField(18, 0);
727                return retVal;
728    }
729    
730    /**
731     * Returns
732     * PID-18: "PATIENT ACCOUNT NUMBER" - creates it if necessary
733     */
734    public CK getPid18_PATIENTACCOUNTNUMBER() { 
735                CK retVal = this.getTypedField(18, 0);
736                return retVal;
737    }
738
739
740
741    /**
742     * Returns
743     * PID-19: "SSN NUMBER - PATIENT" - creates it if necessary
744     */
745    public ST getSSNNUMBERPATIENT() { 
746                ST retVal = this.getTypedField(19, 0);
747                return retVal;
748    }
749    
750    /**
751     * Returns
752     * PID-19: "SSN NUMBER - PATIENT" - creates it if necessary
753     */
754    public ST getPid19_SSNNUMBERPATIENT() { 
755                ST retVal = this.getTypedField(19, 0);
756                return retVal;
757    }
758
759
760
761    /**
762     * Returns
763     * PID-20: "DRIVER'S LIC NUM - PATIENT" - creates it if necessary
764     */
765    public CM getDRIVERSLICNUMPATIENT() { 
766                CM retVal = this.getTypedField(20, 0);
767                return retVal;
768    }
769    
770    /**
771     * Returns
772     * PID-20: "DRIVER'S LIC NUM - PATIENT" - creates it if necessary
773     */
774    public CM getPid20_DRIVERSLICNUMPATIENT() { 
775                CM retVal = this.getTypedField(20, 0);
776                return retVal;
777    }
778
779
780
781
782
783    /** {@inheritDoc} */   
784    protected Type createNewTypeWithoutReflection(int field) {
785       switch (field) {
786          case 0: return new SI(getMessage());
787          case 1: return new CK(getMessage());
788          case 2: return new CK(getMessage());
789          case 3: return new ST(getMessage());
790          case 4: return new PN(getMessage());
791          case 5: return new ST(getMessage());
792          case 6: return new DT(getMessage());
793          case 7: return new ID(getMessage(), new Integer( 1 ));
794          case 8: return new PN(getMessage());
795          case 9: return new ID(getMessage(), new Integer( 5 ));
796          case 10: return new AD(getMessage());
797          case 11: return new ID(getMessage(), new Integer( 0 ));
798          case 12: return new TN(getMessage());
799          case 13: return new TN(getMessage());
800          case 14: return new ST(getMessage());
801          case 15: return new ID(getMessage(), new Integer( 2 ));
802          case 16: return new ID(getMessage(), new Integer( 6 ));
803          case 17: return new CK(getMessage());
804          case 18: return new ST(getMessage());
805          case 19: return new CM(getMessage());
806          default: return null;
807       }
808   }
809
810
811}
812