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.v251.segment;
035
036// import ca.uhn.hl7v2.model.v251.group.*;
037import ca.uhn.hl7v2.model.v251.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 PRC message segment (Pricing). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>PRC-1: Primary Key Value - PRC (CE) <b> </b>
053     * <li>PRC-2: Facility ID - PRC (CE) <b>optional repeating</b>
054     * <li>PRC-3: Department (CE) <b>optional repeating</b>
055     * <li>PRC-4: Valid Patient Classes (IS) <b>optional repeating</b>
056     * <li>PRC-5: Price (CP) <b>optional repeating</b>
057     * <li>PRC-6: Formula (ST) <b>optional repeating</b>
058     * <li>PRC-7: Minimum Quantity (NM) <b>optional </b>
059     * <li>PRC-8: Maximum Quantity (NM) <b>optional </b>
060     * <li>PRC-9: Minimum Price (MO) <b>optional </b>
061     * <li>PRC-10: Maximum Price (MO) <b>optional </b>
062     * <li>PRC-11: Effective Start Date (TS) <b>optional </b>
063     * <li>PRC-12: Effective End Date (TS) <b>optional </b>
064     * <li>PRC-13: Price Override Flag (IS) <b>optional </b>
065     * <li>PRC-14: Billing Category (CE) <b>optional repeating</b>
066     * <li>PRC-15: Chargeable Flag (ID) <b>optional </b>
067     * <li>PRC-16: Active/Inactive Flag (ID) <b>optional </b>
068     * <li>PRC-17: Cost (MO) <b>optional </b>
069     * <li>PRC-18: Charge On Indicator (IS) <b>optional </b>
070 * </ul>
071 */
072@SuppressWarnings("unused")
073public class PRC extends AbstractSegment {
074
075    /** 
076     * Creates a new PRC segment
077     */
078    public PRC(Group parent, ModelClassFactory factory) {
079       super(parent, factory);
080       init(factory);
081    }
082
083    private void init(ModelClassFactory factory) {
084       try {
085                                  this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Primary Key Value - PRC");
086                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Facility ID - PRC");
087                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Department");
088                                              this.add(IS.class, false, 0, 1, new Object[]{ getMessage(), new Integer(4) }, "Valid Patient Classes");
089                                  this.add(CP.class, false, 0, 12, new Object[]{ getMessage() }, "Price");
090                                  this.add(ST.class, false, 0, 200, new Object[]{ getMessage() }, "Formula");
091                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Minimum Quantity");
092                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Maximum Quantity");
093                                  this.add(MO.class, false, 1, 12, new Object[]{ getMessage() }, "Minimum Price");
094                                  this.add(MO.class, false, 1, 12, new Object[]{ getMessage() }, "Maximum Price");
095                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Start Date");
096                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective End Date");
097                                              this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(268) }, "Price Override Flag");
098                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Billing Category");
099                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Chargeable Flag");
100                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(183) }, "Active/Inactive Flag");
101                                  this.add(MO.class, false, 1, 12, new Object[]{ getMessage() }, "Cost");
102                                              this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(269) }, "Charge On Indicator");
103       } catch(HL7Exception e) {
104          log.error("Unexpected error creating PRC - this is probably a bug in the source code generator.", e);
105       }
106    }
107
108
109
110    /**
111     * Returns
112     * PRC-1: "Primary Key Value - PRC" - creates it if necessary
113     */
114    public CE getPrimaryKeyValuePRC() { 
115                CE retVal = this.getTypedField(1, 0);
116                return retVal;
117    }
118    
119    /**
120     * Returns
121     * PRC-1: "Primary Key Value - PRC" - creates it if necessary
122     */
123    public CE getPrc1_PrimaryKeyValuePRC() { 
124                CE retVal = this.getTypedField(1, 0);
125                return retVal;
126    }
127
128
129    /**
130     * Returns all repetitions of Facility ID - PRC (PRC-2).
131     */
132    public CE[] getFacilityIDPRC() {
133        CE[] retVal = this.getTypedField(2, new CE[0]);
134        return retVal;
135    }
136
137
138    /**
139     * Returns all repetitions of Facility ID - PRC (PRC-2).
140     */
141    public CE[] getPrc2_FacilityIDPRC() {
142        CE[] retVal = this.getTypedField(2, new CE[0]);
143        return retVal;
144    }
145
146
147    /**
148     * Returns a count of the current number of repetitions of Facility ID - PRC (PRC-2).
149     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
150     * it will return zero.
151     */
152    public int getFacilityIDPRCReps() {
153        return this.getReps(2);
154    }
155
156
157    /**
158     * Returns a specific repetition of
159     * PRC-2: "Facility ID - PRC" - creates it if necessary
160     *
161     * @param rep The repetition index (0-indexed)
162     */
163    public CE getFacilityIDPRC(int rep) { 
164                CE retVal = this.getTypedField(2, rep);
165                return retVal;
166    }
167
168    /**
169     * Returns a specific repetition of
170     * PRC-2: "Facility ID - PRC" - creates it if necessary
171     *
172     * @param rep The repetition index (0-indexed)
173     */
174    public CE getPrc2_FacilityIDPRC(int rep) { 
175                CE retVal = this.getTypedField(2, rep);
176                return retVal;
177    }
178
179    /**
180     * Returns a count of the current number of repetitions of Facility ID - PRC (PRC-2).
181     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
182     * it will return zero.
183     */
184    public int getPrc2_FacilityIDPRCReps() {
185        return this.getReps(2);
186    }
187
188
189    /**
190     * Inserts a repetition of
191     * PRC-2: "Facility ID - PRC" at a specific index
192     *
193     * @param rep The repetition index (0-indexed)
194     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
195     */
196    public CE insertFacilityIDPRC(int rep) throws HL7Exception { 
197        return (CE) super.insertRepetition(2, rep);
198    }
199
200
201    /**
202     * Inserts a repetition of
203     * PRC-2: "Facility ID - PRC" at a specific index
204     *
205     * @param rep The repetition index (0-indexed)
206     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
207     */
208    public CE insertPrc2_FacilityIDPRC(int rep) throws HL7Exception { 
209        return (CE) super.insertRepetition(2, rep);
210    }
211
212
213    /**
214     * Removes a repetition of
215     * PRC-2: "Facility ID - PRC" at a specific index
216     *
217     * @param rep The repetition index (0-indexed)
218     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
219     */
220    public CE removeFacilityIDPRC(int rep) throws HL7Exception { 
221        return (CE) super.removeRepetition(2, rep);
222    }
223
224
225    /**
226     * Removes a repetition of
227     * PRC-2: "Facility ID - PRC" at a specific index
228     *
229     * @param rep The repetition index (0-indexed)
230     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
231     */
232    public CE removePrc2_FacilityIDPRC(int rep) throws HL7Exception { 
233        return (CE) super.removeRepetition(2, rep);
234    }
235
236
237
238    /**
239     * Returns all repetitions of Department (PRC-3).
240     */
241    public CE[] getDepartment() {
242        CE[] retVal = this.getTypedField(3, new CE[0]);
243        return retVal;
244    }
245
246
247    /**
248     * Returns all repetitions of Department (PRC-3).
249     */
250    public CE[] getPrc3_Department() {
251        CE[] retVal = this.getTypedField(3, new CE[0]);
252        return retVal;
253    }
254
255
256    /**
257     * Returns a count of the current number of repetitions of Department (PRC-3).
258     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
259     * it will return zero.
260     */
261    public int getDepartmentReps() {
262        return this.getReps(3);
263    }
264
265
266    /**
267     * Returns a specific repetition of
268     * PRC-3: "Department" - creates it if necessary
269     *
270     * @param rep The repetition index (0-indexed)
271     */
272    public CE getDepartment(int rep) { 
273                CE retVal = this.getTypedField(3, rep);
274                return retVal;
275    }
276
277    /**
278     * Returns a specific repetition of
279     * PRC-3: "Department" - creates it if necessary
280     *
281     * @param rep The repetition index (0-indexed)
282     */
283    public CE getPrc3_Department(int rep) { 
284                CE retVal = this.getTypedField(3, rep);
285                return retVal;
286    }
287
288    /**
289     * Returns a count of the current number of repetitions of Department (PRC-3).
290     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
291     * it will return zero.
292     */
293    public int getPrc3_DepartmentReps() {
294        return this.getReps(3);
295    }
296
297
298    /**
299     * Inserts a repetition of
300     * PRC-3: "Department" at a specific index
301     *
302     * @param rep The repetition index (0-indexed)
303     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
304     */
305    public CE insertDepartment(int rep) throws HL7Exception { 
306        return (CE) super.insertRepetition(3, rep);
307    }
308
309
310    /**
311     * Inserts a repetition of
312     * PRC-3: "Department" at a specific index
313     *
314     * @param rep The repetition index (0-indexed)
315     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
316     */
317    public CE insertPrc3_Department(int rep) throws HL7Exception { 
318        return (CE) super.insertRepetition(3, rep);
319    }
320
321
322    /**
323     * Removes a repetition of
324     * PRC-3: "Department" at a specific index
325     *
326     * @param rep The repetition index (0-indexed)
327     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
328     */
329    public CE removeDepartment(int rep) throws HL7Exception { 
330        return (CE) super.removeRepetition(3, rep);
331    }
332
333
334    /**
335     * Removes a repetition of
336     * PRC-3: "Department" at a specific index
337     *
338     * @param rep The repetition index (0-indexed)
339     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
340     */
341    public CE removePrc3_Department(int rep) throws HL7Exception { 
342        return (CE) super.removeRepetition(3, rep);
343    }
344
345
346
347    /**
348     * Returns all repetitions of Valid Patient Classes (PRC-4).
349     */
350    public IS[] getValidPatientClasses() {
351        IS[] retVal = this.getTypedField(4, new IS[0]);
352        return retVal;
353    }
354
355
356    /**
357     * Returns all repetitions of Valid Patient Classes (PRC-4).
358     */
359    public IS[] getPrc4_ValidPatientClasses() {
360        IS[] retVal = this.getTypedField(4, new IS[0]);
361        return retVal;
362    }
363
364
365    /**
366     * Returns a count of the current number of repetitions of Valid Patient Classes (PRC-4).
367     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
368     * it will return zero.
369     */
370    public int getValidPatientClassesReps() {
371        return this.getReps(4);
372    }
373
374
375    /**
376     * Returns a specific repetition of
377     * PRC-4: "Valid Patient Classes" - creates it if necessary
378     *
379     * @param rep The repetition index (0-indexed)
380     */
381    public IS getValidPatientClasses(int rep) { 
382                IS retVal = this.getTypedField(4, rep);
383                return retVal;
384    }
385
386    /**
387     * Returns a specific repetition of
388     * PRC-4: "Valid Patient Classes" - creates it if necessary
389     *
390     * @param rep The repetition index (0-indexed)
391     */
392    public IS getPrc4_ValidPatientClasses(int rep) { 
393                IS retVal = this.getTypedField(4, rep);
394                return retVal;
395    }
396
397    /**
398     * Returns a count of the current number of repetitions of Valid Patient Classes (PRC-4).
399     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
400     * it will return zero.
401     */
402    public int getPrc4_ValidPatientClassesReps() {
403        return this.getReps(4);
404    }
405
406
407    /**
408     * Inserts a repetition of
409     * PRC-4: "Valid Patient Classes" at a specific index
410     *
411     * @param rep The repetition index (0-indexed)
412     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
413     */
414    public IS insertValidPatientClasses(int rep) throws HL7Exception { 
415        return (IS) super.insertRepetition(4, rep);
416    }
417
418
419    /**
420     * Inserts a repetition of
421     * PRC-4: "Valid Patient Classes" at a specific index
422     *
423     * @param rep The repetition index (0-indexed)
424     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
425     */
426    public IS insertPrc4_ValidPatientClasses(int rep) throws HL7Exception { 
427        return (IS) super.insertRepetition(4, rep);
428    }
429
430
431    /**
432     * Removes a repetition of
433     * PRC-4: "Valid Patient Classes" at a specific index
434     *
435     * @param rep The repetition index (0-indexed)
436     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
437     */
438    public IS removeValidPatientClasses(int rep) throws HL7Exception { 
439        return (IS) super.removeRepetition(4, rep);
440    }
441
442
443    /**
444     * Removes a repetition of
445     * PRC-4: "Valid Patient Classes" at a specific index
446     *
447     * @param rep The repetition index (0-indexed)
448     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
449     */
450    public IS removePrc4_ValidPatientClasses(int rep) throws HL7Exception { 
451        return (IS) super.removeRepetition(4, rep);
452    }
453
454
455
456    /**
457     * Returns all repetitions of Price (PRC-5).
458     */
459    public CP[] getPrice() {
460        CP[] retVal = this.getTypedField(5, new CP[0]);
461        return retVal;
462    }
463
464
465    /**
466     * Returns all repetitions of Price (PRC-5).
467     */
468    public CP[] getPrc5_Price() {
469        CP[] retVal = this.getTypedField(5, new CP[0]);
470        return retVal;
471    }
472
473
474    /**
475     * Returns a count of the current number of repetitions of Price (PRC-5).
476     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
477     * it will return zero.
478     */
479    public int getPriceReps() {
480        return this.getReps(5);
481    }
482
483
484    /**
485     * Returns a specific repetition of
486     * PRC-5: "Price" - creates it if necessary
487     *
488     * @param rep The repetition index (0-indexed)
489     */
490    public CP getPrice(int rep) { 
491                CP retVal = this.getTypedField(5, rep);
492                return retVal;
493    }
494
495    /**
496     * Returns a specific repetition of
497     * PRC-5: "Price" - creates it if necessary
498     *
499     * @param rep The repetition index (0-indexed)
500     */
501    public CP getPrc5_Price(int rep) { 
502                CP retVal = this.getTypedField(5, rep);
503                return retVal;
504    }
505
506    /**
507     * Returns a count of the current number of repetitions of Price (PRC-5).
508     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
509     * it will return zero.
510     */
511    public int getPrc5_PriceReps() {
512        return this.getReps(5);
513    }
514
515
516    /**
517     * Inserts a repetition of
518     * PRC-5: "Price" at a specific index
519     *
520     * @param rep The repetition index (0-indexed)
521     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
522     */
523    public CP insertPrice(int rep) throws HL7Exception { 
524        return (CP) super.insertRepetition(5, rep);
525    }
526
527
528    /**
529     * Inserts a repetition of
530     * PRC-5: "Price" at a specific index
531     *
532     * @param rep The repetition index (0-indexed)
533     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
534     */
535    public CP insertPrc5_Price(int rep) throws HL7Exception { 
536        return (CP) super.insertRepetition(5, rep);
537    }
538
539
540    /**
541     * Removes a repetition of
542     * PRC-5: "Price" at a specific index
543     *
544     * @param rep The repetition index (0-indexed)
545     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
546     */
547    public CP removePrice(int rep) throws HL7Exception { 
548        return (CP) super.removeRepetition(5, rep);
549    }
550
551
552    /**
553     * Removes a repetition of
554     * PRC-5: "Price" at a specific index
555     *
556     * @param rep The repetition index (0-indexed)
557     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
558     */
559    public CP removePrc5_Price(int rep) throws HL7Exception { 
560        return (CP) super.removeRepetition(5, rep);
561    }
562
563
564
565    /**
566     * Returns all repetitions of Formula (PRC-6).
567     */
568    public ST[] getFormula() {
569        ST[] retVal = this.getTypedField(6, new ST[0]);
570        return retVal;
571    }
572
573
574    /**
575     * Returns all repetitions of Formula (PRC-6).
576     */
577    public ST[] getPrc6_Formula() {
578        ST[] retVal = this.getTypedField(6, new ST[0]);
579        return retVal;
580    }
581
582
583    /**
584     * Returns a count of the current number of repetitions of Formula (PRC-6).
585     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
586     * it will return zero.
587     */
588    public int getFormulaReps() {
589        return this.getReps(6);
590    }
591
592
593    /**
594     * Returns a specific repetition of
595     * PRC-6: "Formula" - creates it if necessary
596     *
597     * @param rep The repetition index (0-indexed)
598     */
599    public ST getFormula(int rep) { 
600                ST retVal = this.getTypedField(6, rep);
601                return retVal;
602    }
603
604    /**
605     * Returns a specific repetition of
606     * PRC-6: "Formula" - creates it if necessary
607     *
608     * @param rep The repetition index (0-indexed)
609     */
610    public ST getPrc6_Formula(int rep) { 
611                ST retVal = this.getTypedField(6, rep);
612                return retVal;
613    }
614
615    /**
616     * Returns a count of the current number of repetitions of Formula (PRC-6).
617     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
618     * it will return zero.
619     */
620    public int getPrc6_FormulaReps() {
621        return this.getReps(6);
622    }
623
624
625    /**
626     * Inserts a repetition of
627     * PRC-6: "Formula" at a specific index
628     *
629     * @param rep The repetition index (0-indexed)
630     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
631     */
632    public ST insertFormula(int rep) throws HL7Exception { 
633        return (ST) super.insertRepetition(6, rep);
634    }
635
636
637    /**
638     * Inserts a repetition of
639     * PRC-6: "Formula" at a specific index
640     *
641     * @param rep The repetition index (0-indexed)
642     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
643     */
644    public ST insertPrc6_Formula(int rep) throws HL7Exception { 
645        return (ST) super.insertRepetition(6, rep);
646    }
647
648
649    /**
650     * Removes a repetition of
651     * PRC-6: "Formula" at a specific index
652     *
653     * @param rep The repetition index (0-indexed)
654     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
655     */
656    public ST removeFormula(int rep) throws HL7Exception { 
657        return (ST) super.removeRepetition(6, rep);
658    }
659
660
661    /**
662     * Removes a repetition of
663     * PRC-6: "Formula" at a specific index
664     *
665     * @param rep The repetition index (0-indexed)
666     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
667     */
668    public ST removePrc6_Formula(int rep) throws HL7Exception { 
669        return (ST) super.removeRepetition(6, rep);
670    }
671
672
673
674
675    /**
676     * Returns
677     * PRC-7: "Minimum Quantity" - creates it if necessary
678     */
679    public NM getMinimumQuantity() { 
680                NM retVal = this.getTypedField(7, 0);
681                return retVal;
682    }
683    
684    /**
685     * Returns
686     * PRC-7: "Minimum Quantity" - creates it if necessary
687     */
688    public NM getPrc7_MinimumQuantity() { 
689                NM retVal = this.getTypedField(7, 0);
690                return retVal;
691    }
692
693
694
695    /**
696     * Returns
697     * PRC-8: "Maximum Quantity" - creates it if necessary
698     */
699    public NM getMaximumQuantity() { 
700                NM retVal = this.getTypedField(8, 0);
701                return retVal;
702    }
703    
704    /**
705     * Returns
706     * PRC-8: "Maximum Quantity" - creates it if necessary
707     */
708    public NM getPrc8_MaximumQuantity() { 
709                NM retVal = this.getTypedField(8, 0);
710                return retVal;
711    }
712
713
714
715    /**
716     * Returns
717     * PRC-9: "Minimum Price" - creates it if necessary
718     */
719    public MO getMinimumPrice() { 
720                MO retVal = this.getTypedField(9, 0);
721                return retVal;
722    }
723    
724    /**
725     * Returns
726     * PRC-9: "Minimum Price" - creates it if necessary
727     */
728    public MO getPrc9_MinimumPrice() { 
729                MO retVal = this.getTypedField(9, 0);
730                return retVal;
731    }
732
733
734
735    /**
736     * Returns
737     * PRC-10: "Maximum Price" - creates it if necessary
738     */
739    public MO getMaximumPrice() { 
740                MO retVal = this.getTypedField(10, 0);
741                return retVal;
742    }
743    
744    /**
745     * Returns
746     * PRC-10: "Maximum Price" - creates it if necessary
747     */
748    public MO getPrc10_MaximumPrice() { 
749                MO retVal = this.getTypedField(10, 0);
750                return retVal;
751    }
752
753
754
755    /**
756     * Returns
757     * PRC-11: "Effective Start Date" - creates it if necessary
758     */
759    public TS getEffectiveStartDate() { 
760                TS retVal = this.getTypedField(11, 0);
761                return retVal;
762    }
763    
764    /**
765     * Returns
766     * PRC-11: "Effective Start Date" - creates it if necessary
767     */
768    public TS getPrc11_EffectiveStartDate() { 
769                TS retVal = this.getTypedField(11, 0);
770                return retVal;
771    }
772
773
774
775    /**
776     * Returns
777     * PRC-12: "Effective End Date" - creates it if necessary
778     */
779    public TS getEffectiveEndDate() { 
780                TS retVal = this.getTypedField(12, 0);
781                return retVal;
782    }
783    
784    /**
785     * Returns
786     * PRC-12: "Effective End Date" - creates it if necessary
787     */
788    public TS getPrc12_EffectiveEndDate() { 
789                TS retVal = this.getTypedField(12, 0);
790                return retVal;
791    }
792
793
794
795    /**
796     * Returns
797     * PRC-13: "Price Override Flag" - creates it if necessary
798     */
799    public IS getPriceOverrideFlag() { 
800                IS retVal = this.getTypedField(13, 0);
801                return retVal;
802    }
803    
804    /**
805     * Returns
806     * PRC-13: "Price Override Flag" - creates it if necessary
807     */
808    public IS getPrc13_PriceOverrideFlag() { 
809                IS retVal = this.getTypedField(13, 0);
810                return retVal;
811    }
812
813
814    /**
815     * Returns all repetitions of Billing Category (PRC-14).
816     */
817    public CE[] getBillingCategory() {
818        CE[] retVal = this.getTypedField(14, new CE[0]);
819        return retVal;
820    }
821
822
823    /**
824     * Returns all repetitions of Billing Category (PRC-14).
825     */
826    public CE[] getPrc14_BillingCategory() {
827        CE[] retVal = this.getTypedField(14, new CE[0]);
828        return retVal;
829    }
830
831
832    /**
833     * Returns a count of the current number of repetitions of Billing Category (PRC-14).
834     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
835     * it will return zero.
836     */
837    public int getBillingCategoryReps() {
838        return this.getReps(14);
839    }
840
841
842    /**
843     * Returns a specific repetition of
844     * PRC-14: "Billing Category" - creates it if necessary
845     *
846     * @param rep The repetition index (0-indexed)
847     */
848    public CE getBillingCategory(int rep) { 
849                CE retVal = this.getTypedField(14, rep);
850                return retVal;
851    }
852
853    /**
854     * Returns a specific repetition of
855     * PRC-14: "Billing Category" - creates it if necessary
856     *
857     * @param rep The repetition index (0-indexed)
858     */
859    public CE getPrc14_BillingCategory(int rep) { 
860                CE retVal = this.getTypedField(14, rep);
861                return retVal;
862    }
863
864    /**
865     * Returns a count of the current number of repetitions of Billing Category (PRC-14).
866     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
867     * it will return zero.
868     */
869    public int getPrc14_BillingCategoryReps() {
870        return this.getReps(14);
871    }
872
873
874    /**
875     * Inserts a repetition of
876     * PRC-14: "Billing Category" at a specific index
877     *
878     * @param rep The repetition index (0-indexed)
879     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
880     */
881    public CE insertBillingCategory(int rep) throws HL7Exception { 
882        return (CE) super.insertRepetition(14, rep);
883    }
884
885
886    /**
887     * Inserts a repetition of
888     * PRC-14: "Billing Category" at a specific index
889     *
890     * @param rep The repetition index (0-indexed)
891     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
892     */
893    public CE insertPrc14_BillingCategory(int rep) throws HL7Exception { 
894        return (CE) super.insertRepetition(14, rep);
895    }
896
897
898    /**
899     * Removes a repetition of
900     * PRC-14: "Billing Category" at a specific index
901     *
902     * @param rep The repetition index (0-indexed)
903     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
904     */
905    public CE removeBillingCategory(int rep) throws HL7Exception { 
906        return (CE) super.removeRepetition(14, rep);
907    }
908
909
910    /**
911     * Removes a repetition of
912     * PRC-14: "Billing Category" at a specific index
913     *
914     * @param rep The repetition index (0-indexed)
915     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
916     */
917    public CE removePrc14_BillingCategory(int rep) throws HL7Exception { 
918        return (CE) super.removeRepetition(14, rep);
919    }
920
921
922
923
924    /**
925     * Returns
926     * PRC-15: "Chargeable Flag" - creates it if necessary
927     */
928    public ID getChargeableFlag() { 
929                ID retVal = this.getTypedField(15, 0);
930                return retVal;
931    }
932    
933    /**
934     * Returns
935     * PRC-15: "Chargeable Flag" - creates it if necessary
936     */
937    public ID getPrc15_ChargeableFlag() { 
938                ID retVal = this.getTypedField(15, 0);
939                return retVal;
940    }
941
942
943
944    /**
945     * Returns
946     * PRC-16: "Active/Inactive Flag" - creates it if necessary
947     */
948    public ID getActiveInactiveFlag() { 
949                ID retVal = this.getTypedField(16, 0);
950                return retVal;
951    }
952    
953    /**
954     * Returns
955     * PRC-16: "Active/Inactive Flag" - creates it if necessary
956     */
957    public ID getPrc16_ActiveInactiveFlag() { 
958                ID retVal = this.getTypedField(16, 0);
959                return retVal;
960    }
961
962
963
964    /**
965     * Returns
966     * PRC-17: "Cost" - creates it if necessary
967     */
968    public MO getCost() { 
969                MO retVal = this.getTypedField(17, 0);
970                return retVal;
971    }
972    
973    /**
974     * Returns
975     * PRC-17: "Cost" - creates it if necessary
976     */
977    public MO getPrc17_Cost() { 
978                MO retVal = this.getTypedField(17, 0);
979                return retVal;
980    }
981
982
983
984    /**
985     * Returns
986     * PRC-18: "Charge On Indicator" - creates it if necessary
987     */
988    public IS getChargeOnIndicator() { 
989                IS retVal = this.getTypedField(18, 0);
990                return retVal;
991    }
992    
993    /**
994     * Returns
995     * PRC-18: "Charge On Indicator" - creates it if necessary
996     */
997    public IS getPrc18_ChargeOnIndicator() { 
998                IS retVal = this.getTypedField(18, 0);
999                return retVal;
1000    }
1001
1002
1003
1004
1005
1006    /** {@inheritDoc} */   
1007    protected Type createNewTypeWithoutReflection(int field) {
1008       switch (field) {
1009          case 0: return new CE(getMessage());
1010          case 1: return new CE(getMessage());
1011          case 2: return new CE(getMessage());
1012          case 3: return new IS(getMessage(), new Integer( 4 ));
1013          case 4: return new CP(getMessage());
1014          case 5: return new ST(getMessage());
1015          case 6: return new NM(getMessage());
1016          case 7: return new NM(getMessage());
1017          case 8: return new MO(getMessage());
1018          case 9: return new MO(getMessage());
1019          case 10: return new TS(getMessage());
1020          case 11: return new TS(getMessage());
1021          case 12: return new IS(getMessage(), new Integer( 268 ));
1022          case 13: return new CE(getMessage());
1023          case 14: return new ID(getMessage(), new Integer( 136 ));
1024          case 15: return new ID(getMessage(), new Integer( 183 ));
1025          case 16: return new MO(getMessage());
1026          case 17: return new IS(getMessage(), new Integer( 269 ));
1027          default: return null;
1028       }
1029   }
1030
1031
1032}
1033