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.v26.message; 035 036import ca.uhn.hl7v2.model.v26.group.*; 037import ca.uhn.hl7v2.model.v26.segment.*; 038 039import ca.uhn.hl7v2.HL7Exception; 040import ca.uhn.hl7v2.parser.ModelClassFactory; 041import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 042import ca.uhn.hl7v2.model.*; 043 044 045/** 046 * <p>Represents a ADT_AXX message structure (see chapter ). This structure contains the 047 * following elements: </p> 048 * <ul> 049 * <li>1: MSH () <b> </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 050 * <li>2: SFT () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 051 * <li>3: UAC () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 052 * <li>4: EVN () <b> </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 053 * <li>5: PID () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 054 * <li>6: PD1 () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 055 * <li>7: ARV () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49]</li></ul></li> 056 * <li>8: ROL () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62]</li></ul></li> 057 * <li>9: MRG () <b>optional </b> <ul><li>Used for the following structures: [ADT_A07, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51]</li></ul></li> 058 * <li>10: NK1 () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 059 * <li>11: PV1 () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A51, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 060 * <li>12: PV2 () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A53, ADT_A55, ADT_A62]</li></ul></li> 061 * <li>13: ARV () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 062 * <li>14: ROL () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62]</li></ul></li> 063 * <li>15: DB1 () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33]</li></ul></li> 064 * <li>16: OBX () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33]</li></ul></li> 065 * <li>17: AL1 () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 066 * <li>18: DG1 () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 067 * <li>19: DRG () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 068 * <li>20: ADT_AXX_PROCEDURE () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07]</li></ul></li> 069 * <li>21: GT1 () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 070 * <li>22: ADT_AXX_INSURANCE () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07]</li></ul></li> 071 * <li>23: ACC () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 072 * <li>24: UB1 () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 073 * <li>25: UB2 () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31]</li></ul></li> 074 * <li>26: PDA () <b>optional </b> <ul><li>Used for the following structures: [ADT_A04, ADT_A08, ADT_A13]</li></ul></li> 075 * <li>27: PID () <b>optional </b> </li> 076 * <li>28: PD1 () <b>optional </b> </li> 077 * <li>29: PV1 () <b>optional </b> </li> 078 * <li>30: PV2 () <b>optional </b> </li> 079 * <li>31: DB1 () <b>optional repeating</b> </li> 080 * <li>32: OBX () <b>optional repeating</b> </li> 081 * <li>33: NPU () <b>optional </b> </li> 082 * <li>34: ADT_AXX_PATIENT () <b>optional repeating</b> <ul><li>Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44]</li></ul></li> 083 * <li>35: ADT_AXX_MERGE_INFO () <b>optional repeating</b> </li> 084 * <li>36: IAM () <b>optional repeating</b> </li> 085 * </ul> 086 */ 087//@SuppressWarnings("unused") 088public class ADT_AXX extends AbstractSuperMessage { 089 090 /** 091 * Creates a new ADT_AXX message with DefaultModelClassFactory. 092 */ 093 public ADT_AXX() { 094 this(new DefaultModelClassFactory()); 095 } 096 097 /** 098 * Creates a new ADT_AXX message with custom ModelClassFactory. 099 */ 100 public ADT_AXX(ModelClassFactory factory) { 101 super(factory); 102 init(factory); 103 } 104 105 private void init(ModelClassFactory factory) { 106 try { 107 this.add(MSH.class, true, false); 108 this.addSuperstructureApplication("MSH", "ADT_A04"); 109 this.addSuperstructureApplication("MSH", "ADT_A07"); 110 this.addSuperstructureApplication("MSH", "ADT_A08"); 111 this.addSuperstructureApplication("MSH", "ADT_A10"); 112 this.addSuperstructureApplication("MSH", "ADT_A11"); 113 this.addSuperstructureApplication("MSH", "ADT_A13"); 114 this.addSuperstructureApplication("MSH", "ADT_A14"); 115 this.addSuperstructureApplication("MSH", "ADT_A22"); 116 this.addSuperstructureApplication("MSH", "ADT_A23"); 117 this.addSuperstructureApplication("MSH", "ADT_A25"); 118 this.addSuperstructureApplication("MSH", "ADT_A26"); 119 this.addSuperstructureApplication("MSH", "ADT_A27"); 120 this.addSuperstructureApplication("MSH", "ADT_A28"); 121 this.addSuperstructureApplication("MSH", "ADT_A29"); 122 this.addSuperstructureApplication("MSH", "ADT_A31"); 123 this.addSuperstructureApplication("MSH", "ADT_A32"); 124 this.addSuperstructureApplication("MSH", "ADT_A33"); 125 this.addSuperstructureApplication("MSH", "ADT_A34"); 126 this.addSuperstructureApplication("MSH", "ADT_A35"); 127 this.addSuperstructureApplication("MSH", "ADT_A36"); 128 this.addSuperstructureApplication("MSH", "ADT_A40"); 129 this.addSuperstructureApplication("MSH", "ADT_A41"); 130 this.addSuperstructureApplication("MSH", "ADT_A42"); 131 this.addSuperstructureApplication("MSH", "ADT_A44"); 132 this.addSuperstructureApplication("MSH", "ADT_A46"); 133 this.addSuperstructureApplication("MSH", "ADT_A47"); 134 this.addSuperstructureApplication("MSH", "ADT_A48"); 135 this.addSuperstructureApplication("MSH", "ADT_A49"); 136 this.addSuperstructureApplication("MSH", "ADT_A51"); 137 this.addSuperstructureApplication("MSH", "ADT_A53"); 138 this.addSuperstructureApplication("MSH", "ADT_A55"); 139 this.addSuperstructureApplication("MSH", "ADT_A62"); 140 this.add(SFT.class, false, true); 141 this.addSuperstructureApplication("SFT", "ADT_A04"); 142 this.addSuperstructureApplication("SFT", "ADT_A07"); 143 this.addSuperstructureApplication("SFT", "ADT_A08"); 144 this.addSuperstructureApplication("SFT", "ADT_A10"); 145 this.addSuperstructureApplication("SFT", "ADT_A11"); 146 this.addSuperstructureApplication("SFT", "ADT_A13"); 147 this.addSuperstructureApplication("SFT", "ADT_A14"); 148 this.addSuperstructureApplication("SFT", "ADT_A22"); 149 this.addSuperstructureApplication("SFT", "ADT_A23"); 150 this.addSuperstructureApplication("SFT", "ADT_A25"); 151 this.addSuperstructureApplication("SFT", "ADT_A26"); 152 this.addSuperstructureApplication("SFT", "ADT_A27"); 153 this.addSuperstructureApplication("SFT", "ADT_A28"); 154 this.addSuperstructureApplication("SFT", "ADT_A29"); 155 this.addSuperstructureApplication("SFT", "ADT_A31"); 156 this.addSuperstructureApplication("SFT", "ADT_A32"); 157 this.addSuperstructureApplication("SFT", "ADT_A33"); 158 this.addSuperstructureApplication("SFT", "ADT_A34"); 159 this.addSuperstructureApplication("SFT", "ADT_A35"); 160 this.addSuperstructureApplication("SFT", "ADT_A36"); 161 this.addSuperstructureApplication("SFT", "ADT_A40"); 162 this.addSuperstructureApplication("SFT", "ADT_A41"); 163 this.addSuperstructureApplication("SFT", "ADT_A42"); 164 this.addSuperstructureApplication("SFT", "ADT_A44"); 165 this.addSuperstructureApplication("SFT", "ADT_A46"); 166 this.addSuperstructureApplication("SFT", "ADT_A47"); 167 this.addSuperstructureApplication("SFT", "ADT_A48"); 168 this.addSuperstructureApplication("SFT", "ADT_A49"); 169 this.addSuperstructureApplication("SFT", "ADT_A51"); 170 this.addSuperstructureApplication("SFT", "ADT_A53"); 171 this.addSuperstructureApplication("SFT", "ADT_A55"); 172 this.addSuperstructureApplication("SFT", "ADT_A62"); 173 this.add(UAC.class, false, false); 174 this.addSuperstructureApplication("UAC", "ADT_A04"); 175 this.addSuperstructureApplication("UAC", "ADT_A07"); 176 this.addSuperstructureApplication("UAC", "ADT_A08"); 177 this.addSuperstructureApplication("UAC", "ADT_A10"); 178 this.addSuperstructureApplication("UAC", "ADT_A11"); 179 this.addSuperstructureApplication("UAC", "ADT_A13"); 180 this.addSuperstructureApplication("UAC", "ADT_A14"); 181 this.addSuperstructureApplication("UAC", "ADT_A22"); 182 this.addSuperstructureApplication("UAC", "ADT_A23"); 183 this.addSuperstructureApplication("UAC", "ADT_A25"); 184 this.addSuperstructureApplication("UAC", "ADT_A26"); 185 this.addSuperstructureApplication("UAC", "ADT_A27"); 186 this.addSuperstructureApplication("UAC", "ADT_A28"); 187 this.addSuperstructureApplication("UAC", "ADT_A29"); 188 this.addSuperstructureApplication("UAC", "ADT_A31"); 189 this.addSuperstructureApplication("UAC", "ADT_A32"); 190 this.addSuperstructureApplication("UAC", "ADT_A33"); 191 this.addSuperstructureApplication("UAC", "ADT_A34"); 192 this.addSuperstructureApplication("UAC", "ADT_A35"); 193 this.addSuperstructureApplication("UAC", "ADT_A36"); 194 this.addSuperstructureApplication("UAC", "ADT_A40"); 195 this.addSuperstructureApplication("UAC", "ADT_A41"); 196 this.addSuperstructureApplication("UAC", "ADT_A42"); 197 this.addSuperstructureApplication("UAC", "ADT_A44"); 198 this.addSuperstructureApplication("UAC", "ADT_A46"); 199 this.addSuperstructureApplication("UAC", "ADT_A47"); 200 this.addSuperstructureApplication("UAC", "ADT_A48"); 201 this.addSuperstructureApplication("UAC", "ADT_A49"); 202 this.addSuperstructureApplication("UAC", "ADT_A51"); 203 this.addSuperstructureApplication("UAC", "ADT_A53"); 204 this.addSuperstructureApplication("UAC", "ADT_A55"); 205 this.addSuperstructureApplication("UAC", "ADT_A62"); 206 this.add(EVN.class, true, false); 207 this.addSuperstructureApplication("EVN", "ADT_A04"); 208 this.addSuperstructureApplication("EVN", "ADT_A07"); 209 this.addSuperstructureApplication("EVN", "ADT_A08"); 210 this.addSuperstructureApplication("EVN", "ADT_A10"); 211 this.addSuperstructureApplication("EVN", "ADT_A11"); 212 this.addSuperstructureApplication("EVN", "ADT_A13"); 213 this.addSuperstructureApplication("EVN", "ADT_A14"); 214 this.addSuperstructureApplication("EVN", "ADT_A22"); 215 this.addSuperstructureApplication("EVN", "ADT_A23"); 216 this.addSuperstructureApplication("EVN", "ADT_A25"); 217 this.addSuperstructureApplication("EVN", "ADT_A26"); 218 this.addSuperstructureApplication("EVN", "ADT_A27"); 219 this.addSuperstructureApplication("EVN", "ADT_A28"); 220 this.addSuperstructureApplication("EVN", "ADT_A29"); 221 this.addSuperstructureApplication("EVN", "ADT_A31"); 222 this.addSuperstructureApplication("EVN", "ADT_A32"); 223 this.addSuperstructureApplication("EVN", "ADT_A33"); 224 this.addSuperstructureApplication("EVN", "ADT_A34"); 225 this.addSuperstructureApplication("EVN", "ADT_A35"); 226 this.addSuperstructureApplication("EVN", "ADT_A36"); 227 this.addSuperstructureApplication("EVN", "ADT_A40"); 228 this.addSuperstructureApplication("EVN", "ADT_A41"); 229 this.addSuperstructureApplication("EVN", "ADT_A42"); 230 this.addSuperstructureApplication("EVN", "ADT_A44"); 231 this.addSuperstructureApplication("EVN", "ADT_A46"); 232 this.addSuperstructureApplication("EVN", "ADT_A47"); 233 this.addSuperstructureApplication("EVN", "ADT_A48"); 234 this.addSuperstructureApplication("EVN", "ADT_A49"); 235 this.addSuperstructureApplication("EVN", "ADT_A51"); 236 this.addSuperstructureApplication("EVN", "ADT_A53"); 237 this.addSuperstructureApplication("EVN", "ADT_A55"); 238 this.addSuperstructureApplication("EVN", "ADT_A62"); 239 this.add(PID.class, false, false); 240 this.addSuperstructureApplication("PID", "ADT_A04"); 241 this.addSuperstructureApplication("PID", "ADT_A07"); 242 this.addSuperstructureApplication("PID", "ADT_A08"); 243 this.addSuperstructureApplication("PID", "ADT_A10"); 244 this.addSuperstructureApplication("PID", "ADT_A11"); 245 this.addSuperstructureApplication("PID", "ADT_A13"); 246 this.addSuperstructureApplication("PID", "ADT_A14"); 247 this.addSuperstructureApplication("PID", "ADT_A22"); 248 this.addSuperstructureApplication("PID", "ADT_A23"); 249 this.addSuperstructureApplication("PID", "ADT_A25"); 250 this.addSuperstructureApplication("PID", "ADT_A26"); 251 this.addSuperstructureApplication("PID", "ADT_A27"); 252 this.addSuperstructureApplication("PID", "ADT_A28"); 253 this.addSuperstructureApplication("PID", "ADT_A29"); 254 this.addSuperstructureApplication("PID", "ADT_A31"); 255 this.addSuperstructureApplication("PID", "ADT_A32"); 256 this.addSuperstructureApplication("PID", "ADT_A33"); 257 this.addSuperstructureApplication("PID", "ADT_A34"); 258 this.addSuperstructureApplication("PID", "ADT_A35"); 259 this.addSuperstructureApplication("PID", "ADT_A36"); 260 this.addSuperstructureApplication("PID", "ADT_A46"); 261 this.addSuperstructureApplication("PID", "ADT_A47"); 262 this.addSuperstructureApplication("PID", "ADT_A48"); 263 this.addSuperstructureApplication("PID", "ADT_A49"); 264 this.addSuperstructureApplication("PID", "ADT_A51"); 265 this.addSuperstructureApplication("PID", "ADT_A53"); 266 this.addSuperstructureApplication("PID", "ADT_A55"); 267 this.addSuperstructureApplication("PID", "ADT_A62"); 268 this.add(PD1.class, false, false); 269 this.addSuperstructureApplication("PD1", "ADT_A04"); 270 this.addSuperstructureApplication("PD1", "ADT_A07"); 271 this.addSuperstructureApplication("PD1", "ADT_A08"); 272 this.addSuperstructureApplication("PD1", "ADT_A10"); 273 this.addSuperstructureApplication("PD1", "ADT_A11"); 274 this.addSuperstructureApplication("PD1", "ADT_A13"); 275 this.addSuperstructureApplication("PD1", "ADT_A14"); 276 this.addSuperstructureApplication("PD1", "ADT_A22"); 277 this.addSuperstructureApplication("PD1", "ADT_A23"); 278 this.addSuperstructureApplication("PD1", "ADT_A25"); 279 this.addSuperstructureApplication("PD1", "ADT_A26"); 280 this.addSuperstructureApplication("PD1", "ADT_A27"); 281 this.addSuperstructureApplication("PD1", "ADT_A28"); 282 this.addSuperstructureApplication("PD1", "ADT_A29"); 283 this.addSuperstructureApplication("PD1", "ADT_A31"); 284 this.addSuperstructureApplication("PD1", "ADT_A32"); 285 this.addSuperstructureApplication("PD1", "ADT_A33"); 286 this.addSuperstructureApplication("PD1", "ADT_A34"); 287 this.addSuperstructureApplication("PD1", "ADT_A35"); 288 this.addSuperstructureApplication("PD1", "ADT_A36"); 289 this.addSuperstructureApplication("PD1", "ADT_A46"); 290 this.addSuperstructureApplication("PD1", "ADT_A47"); 291 this.addSuperstructureApplication("PD1", "ADT_A48"); 292 this.addSuperstructureApplication("PD1", "ADT_A49"); 293 this.addSuperstructureApplication("PD1", "ADT_A51"); 294 this.addSuperstructureApplication("PD1", "ADT_A53"); 295 this.addSuperstructureApplication("PD1", "ADT_A55"); 296 this.addSuperstructureApplication("PD1", "ADT_A62"); 297 this.add(ARV.class, false, true); 298 this.addSuperstructureApplication("ARV", "ADT_A04"); 299 this.addSuperstructureApplication("ARV", "ADT_A07"); 300 this.addSuperstructureApplication("ARV", "ADT_A08"); 301 this.addSuperstructureApplication("ARV", "ADT_A13"); 302 this.addSuperstructureApplication("ARV", "ADT_A14"); 303 this.addSuperstructureApplication("ARV", "ADT_A28"); 304 this.addSuperstructureApplication("ARV", "ADT_A31"); 305 this.addSuperstructureApplication("ARV", "ADT_A34"); 306 this.addSuperstructureApplication("ARV", "ADT_A35"); 307 this.addSuperstructureApplication("ARV", "ADT_A36"); 308 this.addSuperstructureApplication("ARV", "ADT_A46"); 309 this.addSuperstructureApplication("ARV", "ADT_A47"); 310 this.addSuperstructureApplication("ARV", "ADT_A48"); 311 this.addSuperstructureApplication("ARV", "ADT_A49"); 312 this.add(ROL.class, false, true); 313 this.addSuperstructureApplication("ROL", "ADT_A04"); 314 this.addSuperstructureApplication("ROL", "ADT_A07"); 315 this.addSuperstructureApplication("ROL", "ADT_A08"); 316 this.addSuperstructureApplication("ROL", "ADT_A13"); 317 this.addSuperstructureApplication("ROL", "ADT_A14"); 318 this.addSuperstructureApplication("ROL", "ADT_A28"); 319 this.addSuperstructureApplication("ROL", "ADT_A31"); 320 this.addSuperstructureApplication("ROL", "ADT_A55"); 321 this.addSuperstructureApplication("ROL", "ADT_A62"); 322 this.add(MRG.class, false, false); 323 this.addSuperstructureApplication("MRG", "ADT_A07"); 324 this.addSuperstructureApplication("MRG", "ADT_A34"); 325 this.addSuperstructureApplication("MRG", "ADT_A35"); 326 this.addSuperstructureApplication("MRG", "ADT_A36"); 327 this.addSuperstructureApplication("MRG", "ADT_A46"); 328 this.addSuperstructureApplication("MRG", "ADT_A47"); 329 this.addSuperstructureApplication("MRG", "ADT_A48"); 330 this.addSuperstructureApplication("MRG", "ADT_A49"); 331 this.addSuperstructureApplication("MRG", "ADT_A51"); 332 this.add(NK1.class, false, true); 333 this.addSuperstructureApplication("NK1", "ADT_A04"); 334 this.addSuperstructureApplication("NK1", "ADT_A07"); 335 this.addSuperstructureApplication("NK1", "ADT_A08"); 336 this.addSuperstructureApplication("NK1", "ADT_A13"); 337 this.addSuperstructureApplication("NK1", "ADT_A14"); 338 this.addSuperstructureApplication("NK1", "ADT_A28"); 339 this.addSuperstructureApplication("NK1", "ADT_A31"); 340 this.add(PV1.class, false, false); 341 this.addSuperstructureApplication("PV1", "ADT_A04"); 342 this.addSuperstructureApplication("PV1", "ADT_A07"); 343 this.addSuperstructureApplication("PV1", "ADT_A08"); 344 this.addSuperstructureApplication("PV1", "ADT_A10"); 345 this.addSuperstructureApplication("PV1", "ADT_A11"); 346 this.addSuperstructureApplication("PV1", "ADT_A13"); 347 this.addSuperstructureApplication("PV1", "ADT_A14"); 348 this.addSuperstructureApplication("PV1", "ADT_A22"); 349 this.addSuperstructureApplication("PV1", "ADT_A23"); 350 this.addSuperstructureApplication("PV1", "ADT_A25"); 351 this.addSuperstructureApplication("PV1", "ADT_A26"); 352 this.addSuperstructureApplication("PV1", "ADT_A27"); 353 this.addSuperstructureApplication("PV1", "ADT_A28"); 354 this.addSuperstructureApplication("PV1", "ADT_A29"); 355 this.addSuperstructureApplication("PV1", "ADT_A31"); 356 this.addSuperstructureApplication("PV1", "ADT_A32"); 357 this.addSuperstructureApplication("PV1", "ADT_A33"); 358 this.addSuperstructureApplication("PV1", "ADT_A51"); 359 this.addSuperstructureApplication("PV1", "ADT_A53"); 360 this.addSuperstructureApplication("PV1", "ADT_A55"); 361 this.addSuperstructureApplication("PV1", "ADT_A62"); 362 this.add(PV2.class, false, false); 363 this.addSuperstructureApplication("PV2", "ADT_A04"); 364 this.addSuperstructureApplication("PV2", "ADT_A07"); 365 this.addSuperstructureApplication("PV2", "ADT_A08"); 366 this.addSuperstructureApplication("PV2", "ADT_A10"); 367 this.addSuperstructureApplication("PV2", "ADT_A11"); 368 this.addSuperstructureApplication("PV2", "ADT_A13"); 369 this.addSuperstructureApplication("PV2", "ADT_A14"); 370 this.addSuperstructureApplication("PV2", "ADT_A22"); 371 this.addSuperstructureApplication("PV2", "ADT_A23"); 372 this.addSuperstructureApplication("PV2", "ADT_A25"); 373 this.addSuperstructureApplication("PV2", "ADT_A26"); 374 this.addSuperstructureApplication("PV2", "ADT_A27"); 375 this.addSuperstructureApplication("PV2", "ADT_A28"); 376 this.addSuperstructureApplication("PV2", "ADT_A29"); 377 this.addSuperstructureApplication("PV2", "ADT_A31"); 378 this.addSuperstructureApplication("PV2", "ADT_A32"); 379 this.addSuperstructureApplication("PV2", "ADT_A33"); 380 this.addSuperstructureApplication("PV2", "ADT_A53"); 381 this.addSuperstructureApplication("PV2", "ADT_A55"); 382 this.addSuperstructureApplication("PV2", "ADT_A62"); 383 this.add(ARV.class, false, true); 384 this.addSuperstructureApplication("ARV2", "ADT_A04"); 385 this.addSuperstructureApplication("ARV2", "ADT_A07"); 386 this.addSuperstructureApplication("ARV2", "ADT_A08"); 387 this.addSuperstructureApplication("ARV2", "ADT_A13"); 388 this.addSuperstructureApplication("ARV2", "ADT_A14"); 389 this.addSuperstructureApplication("ARV2", "ADT_A28"); 390 this.addSuperstructureApplication("ARV2", "ADT_A31"); 391 this.add(ROL.class, false, true); 392 this.addSuperstructureApplication("ROL2", "ADT_A04"); 393 this.addSuperstructureApplication("ROL2", "ADT_A07"); 394 this.addSuperstructureApplication("ROL2", "ADT_A08"); 395 this.addSuperstructureApplication("ROL2", "ADT_A13"); 396 this.addSuperstructureApplication("ROL2", "ADT_A14"); 397 this.addSuperstructureApplication("ROL2", "ADT_A28"); 398 this.addSuperstructureApplication("ROL2", "ADT_A31"); 399 this.addSuperstructureApplication("ROL2", "ADT_A55"); 400 this.addSuperstructureApplication("ROL2", "ADT_A62"); 401 this.add(DB1.class, false, true); 402 this.addSuperstructureApplication("DB1", "ADT_A04"); 403 this.addSuperstructureApplication("DB1", "ADT_A07"); 404 this.addSuperstructureApplication("DB1", "ADT_A08"); 405 this.addSuperstructureApplication("DB1", "ADT_A10"); 406 this.addSuperstructureApplication("DB1", "ADT_A11"); 407 this.addSuperstructureApplication("DB1", "ADT_A13"); 408 this.addSuperstructureApplication("DB1", "ADT_A14"); 409 this.addSuperstructureApplication("DB1", "ADT_A22"); 410 this.addSuperstructureApplication("DB1", "ADT_A23"); 411 this.addSuperstructureApplication("DB1", "ADT_A25"); 412 this.addSuperstructureApplication("DB1", "ADT_A26"); 413 this.addSuperstructureApplication("DB1", "ADT_A27"); 414 this.addSuperstructureApplication("DB1", "ADT_A28"); 415 this.addSuperstructureApplication("DB1", "ADT_A29"); 416 this.addSuperstructureApplication("DB1", "ADT_A31"); 417 this.addSuperstructureApplication("DB1", "ADT_A32"); 418 this.addSuperstructureApplication("DB1", "ADT_A33"); 419 this.add(OBX.class, false, true); 420 this.addSuperstructureApplication("OBX", "ADT_A04"); 421 this.addSuperstructureApplication("OBX", "ADT_A07"); 422 this.addSuperstructureApplication("OBX", "ADT_A08"); 423 this.addSuperstructureApplication("OBX", "ADT_A10"); 424 this.addSuperstructureApplication("OBX", "ADT_A11"); 425 this.addSuperstructureApplication("OBX", "ADT_A13"); 426 this.addSuperstructureApplication("OBX", "ADT_A14"); 427 this.addSuperstructureApplication("OBX", "ADT_A22"); 428 this.addSuperstructureApplication("OBX", "ADT_A23"); 429 this.addSuperstructureApplication("OBX", "ADT_A25"); 430 this.addSuperstructureApplication("OBX", "ADT_A26"); 431 this.addSuperstructureApplication("OBX", "ADT_A27"); 432 this.addSuperstructureApplication("OBX", "ADT_A28"); 433 this.addSuperstructureApplication("OBX", "ADT_A29"); 434 this.addSuperstructureApplication("OBX", "ADT_A31"); 435 this.addSuperstructureApplication("OBX", "ADT_A32"); 436 this.addSuperstructureApplication("OBX", "ADT_A33"); 437 this.add(AL1.class, false, true); 438 this.addSuperstructureApplication("AL1", "ADT_A04"); 439 this.addSuperstructureApplication("AL1", "ADT_A07"); 440 this.addSuperstructureApplication("AL1", "ADT_A08"); 441 this.addSuperstructureApplication("AL1", "ADT_A13"); 442 this.addSuperstructureApplication("AL1", "ADT_A14"); 443 this.addSuperstructureApplication("AL1", "ADT_A28"); 444 this.addSuperstructureApplication("AL1", "ADT_A31"); 445 this.add(DG1.class, false, true); 446 this.addSuperstructureApplication("DG1", "ADT_A04"); 447 this.addSuperstructureApplication("DG1", "ADT_A07"); 448 this.addSuperstructureApplication("DG1", "ADT_A08"); 449 this.addSuperstructureApplication("DG1", "ADT_A10"); 450 this.addSuperstructureApplication("DG1", "ADT_A11"); 451 this.addSuperstructureApplication("DG1", "ADT_A13"); 452 this.addSuperstructureApplication("DG1", "ADT_A14"); 453 this.addSuperstructureApplication("DG1", "ADT_A28"); 454 this.addSuperstructureApplication("DG1", "ADT_A31"); 455 this.add(DRG.class, false, false); 456 this.addSuperstructureApplication("DRG", "ADT_A04"); 457 this.addSuperstructureApplication("DRG", "ADT_A07"); 458 this.addSuperstructureApplication("DRG", "ADT_A08"); 459 this.addSuperstructureApplication("DRG", "ADT_A13"); 460 this.addSuperstructureApplication("DRG", "ADT_A14"); 461 this.addSuperstructureApplication("DRG", "ADT_A28"); 462 this.addSuperstructureApplication("DRG", "ADT_A31"); 463 this.add(ADT_AXX_PROCEDURE.class, false, true); 464 this.addSuperstructureApplication("PROCEDURE", "ADT_A13"); 465 this.addSuperstructureApplication("PROCEDURE", "ADT_A04"); 466 this.addSuperstructureApplication("PROCEDURE", "ADT_A08"); 467 this.addSuperstructureApplication("PROCEDURE", "ADT_A14"); 468 this.addSuperstructureApplication("PROCEDURE", "ADT_A31"); 469 this.addSuperstructureApplication("PROCEDURE", "ADT_A28"); 470 this.addSuperstructureApplication("PROCEDURE", "ADT_A07"); 471 this.add(GT1.class, false, true); 472 this.addSuperstructureApplication("GT1", "ADT_A04"); 473 this.addSuperstructureApplication("GT1", "ADT_A07"); 474 this.addSuperstructureApplication("GT1", "ADT_A08"); 475 this.addSuperstructureApplication("GT1", "ADT_A13"); 476 this.addSuperstructureApplication("GT1", "ADT_A14"); 477 this.addSuperstructureApplication("GT1", "ADT_A28"); 478 this.addSuperstructureApplication("GT1", "ADT_A31"); 479 this.add(ADT_AXX_INSURANCE.class, false, true); 480 this.addSuperstructureApplication("INSURANCE", "ADT_A13"); 481 this.addSuperstructureApplication("INSURANCE", "ADT_A04"); 482 this.addSuperstructureApplication("INSURANCE", "ADT_A08"); 483 this.addSuperstructureApplication("INSURANCE", "ADT_A14"); 484 this.addSuperstructureApplication("INSURANCE", "ADT_A31"); 485 this.addSuperstructureApplication("INSURANCE", "ADT_A28"); 486 this.addSuperstructureApplication("INSURANCE", "ADT_A07"); 487 this.add(ACC.class, false, false); 488 this.addSuperstructureApplication("ACC", "ADT_A04"); 489 this.addSuperstructureApplication("ACC", "ADT_A07"); 490 this.addSuperstructureApplication("ACC", "ADT_A08"); 491 this.addSuperstructureApplication("ACC", "ADT_A13"); 492 this.addSuperstructureApplication("ACC", "ADT_A14"); 493 this.addSuperstructureApplication("ACC", "ADT_A28"); 494 this.addSuperstructureApplication("ACC", "ADT_A31"); 495 this.add(UB1.class, false, false); 496 this.addSuperstructureApplication("UB1", "ADT_A04"); 497 this.addSuperstructureApplication("UB1", "ADT_A07"); 498 this.addSuperstructureApplication("UB1", "ADT_A08"); 499 this.addSuperstructureApplication("UB1", "ADT_A13"); 500 this.addSuperstructureApplication("UB1", "ADT_A14"); 501 this.addSuperstructureApplication("UB1", "ADT_A28"); 502 this.addSuperstructureApplication("UB1", "ADT_A31"); 503 this.add(UB2.class, false, false); 504 this.addSuperstructureApplication("UB2", "ADT_A04"); 505 this.addSuperstructureApplication("UB2", "ADT_A07"); 506 this.addSuperstructureApplication("UB2", "ADT_A08"); 507 this.addSuperstructureApplication("UB2", "ADT_A13"); 508 this.addSuperstructureApplication("UB2", "ADT_A14"); 509 this.addSuperstructureApplication("UB2", "ADT_A28"); 510 this.addSuperstructureApplication("UB2", "ADT_A31"); 511 this.add(PDA.class, false, false); 512 this.addSuperstructureApplication("PDA", "ADT_A04"); 513 this.addSuperstructureApplication("PDA", "ADT_A08"); 514 this.addSuperstructureApplication("PDA", "ADT_A13"); 515 this.add(PID.class, false, false); 516 this.add(PD1.class, false, false); 517 this.add(PV1.class, false, false); 518 this.add(PV2.class, false, false); 519 this.add(DB1.class, false, true); 520 this.add(OBX.class, false, true); 521 this.add(NPU.class, false, false); 522 this.add(ADT_AXX_PATIENT.class, false, true); 523 this.addSuperstructureApplication("PATIENT", "ADT_A42"); 524 this.addSuperstructureApplication("PATIENT", "ADT_A41"); 525 this.addSuperstructureApplication("PATIENT", "ADT_A40"); 526 this.addSuperstructureApplication("PATIENT", "ADT_A44"); 527 this.add(ADT_AXX_MERGE_INFO.class, false, true); 528 this.add(IAM.class, false, true); 529 } catch(HL7Exception e) { 530 log.error("Unexpected error creating ADT_AXX - this is probably a bug in the source code generator.", e); 531 } 532 } 533 534 public java.util.List<String> getChildNamesForStructure(String theStructure) { 535 java.util.ArrayList<String> retVal = new java.util.ArrayList<String>(); 536 if ( "ADT_A01".equals(theStructure) ) { 537 retVal.add("MSH"); 538 retVal.add("SFT"); 539 retVal.add("UAC"); 540 retVal.add("EVN"); 541 retVal.add("PID"); 542 retVal.add("PD1"); 543 retVal.add("ARV"); 544 retVal.add("ROL"); 545 retVal.add("NK1"); 546 retVal.add("PV1"); 547 retVal.add("PV2"); 548 retVal.add("ARV2"); 549 retVal.add("ROL2"); 550 retVal.add("DB1"); 551 retVal.add("OBX"); 552 retVal.add("AL1"); 553 retVal.add("DG1"); 554 retVal.add("DRG"); 555 retVal.add("PROCEDURE"); 556 retVal.add("GT1"); 557 retVal.add("INSURANCE"); 558 retVal.add("ACC"); 559 retVal.add("UB1"); 560 retVal.add("UB2"); 561 retVal.add("PDA"); 562 } 563 if ( "ADT_A02".equals(theStructure) ) { 564 retVal.add("MSH"); 565 retVal.add("SFT"); 566 retVal.add("UAC"); 567 retVal.add("EVN"); 568 retVal.add("PID"); 569 retVal.add("PD1"); 570 retVal.add("ARV"); 571 retVal.add("ROL"); 572 retVal.add("PV1"); 573 retVal.add("PV2"); 574 retVal.add("ARV2"); 575 retVal.add("ROL2"); 576 retVal.add("DB1"); 577 retVal.add("OBX"); 578 retVal.add("PDA"); 579 } 580 if ( "ADT_A03".equals(theStructure) ) { 581 retVal.add("MSH"); 582 retVal.add("SFT"); 583 retVal.add("UAC"); 584 retVal.add("EVN"); 585 retVal.add("PID"); 586 retVal.add("PD1"); 587 retVal.add("ARV"); 588 retVal.add("ROL"); 589 retVal.add("NK1"); 590 retVal.add("PV1"); 591 retVal.add("PV2"); 592 retVal.add("ARV2"); 593 retVal.add("ROL2"); 594 retVal.add("DB1"); 595 retVal.add("AL1"); 596 retVal.add("DG1"); 597 retVal.add("DRG"); 598 retVal.add("PROCEDURE"); 599 retVal.add("OBX"); 600 retVal.add("GT1"); 601 retVal.add("INSURANCE"); 602 retVal.add("ACC"); 603 retVal.add("PDA"); 604 } 605 if ( "ADT_A05".equals(theStructure) ) { 606 retVal.add("MSH"); 607 retVal.add("SFT"); 608 retVal.add("UAC"); 609 retVal.add("EVN"); 610 retVal.add("PID"); 611 retVal.add("PD1"); 612 retVal.add("ARV"); 613 retVal.add("ROL"); 614 retVal.add("NK1"); 615 retVal.add("PV1"); 616 retVal.add("PV2"); 617 retVal.add("ARV2"); 618 retVal.add("ROL2"); 619 retVal.add("DB1"); 620 retVal.add("OBX"); 621 retVal.add("AL1"); 622 retVal.add("DG1"); 623 retVal.add("DRG"); 624 retVal.add("PROCEDURE"); 625 retVal.add("GT1"); 626 retVal.add("INSURANCE"); 627 retVal.add("ACC"); 628 retVal.add("UB1"); 629 retVal.add("UB2"); 630 } 631 if ( "ADT_A06".equals(theStructure) ) { 632 retVal.add("MSH"); 633 retVal.add("SFT"); 634 retVal.add("UAC"); 635 retVal.add("EVN"); 636 retVal.add("PID"); 637 retVal.add("PD1"); 638 retVal.add("ARV"); 639 retVal.add("ROL"); 640 retVal.add("MRG"); 641 retVal.add("NK1"); 642 retVal.add("PV1"); 643 retVal.add("PV2"); 644 retVal.add("ARV2"); 645 retVal.add("ROL2"); 646 retVal.add("DB1"); 647 retVal.add("OBX"); 648 retVal.add("AL1"); 649 retVal.add("DG1"); 650 retVal.add("DRG"); 651 retVal.add("PROCEDURE"); 652 retVal.add("GT1"); 653 retVal.add("INSURANCE"); 654 retVal.add("ACC"); 655 retVal.add("UB1"); 656 retVal.add("UB2"); 657 } 658 if ( "ADT_A09".equals(theStructure) ) { 659 retVal.add("MSH"); 660 retVal.add("SFT"); 661 retVal.add("UAC"); 662 retVal.add("EVN"); 663 retVal.add("PID"); 664 retVal.add("PD1"); 665 retVal.add("PV1"); 666 retVal.add("PV2"); 667 retVal.add("DB1"); 668 retVal.add("OBX"); 669 retVal.add("DG1"); 670 } 671 if ( "ADT_A12".equals(theStructure) ) { 672 retVal.add("MSH"); 673 retVal.add("SFT"); 674 retVal.add("UAC"); 675 retVal.add("EVN"); 676 retVal.add("PID"); 677 retVal.add("PD1"); 678 retVal.add("PV1"); 679 retVal.add("PV2"); 680 retVal.add("DB1"); 681 retVal.add("OBX"); 682 retVal.add("DG1"); 683 } 684 if ( "ADT_A15".equals(theStructure) ) { 685 retVal.add("MSH"); 686 retVal.add("SFT"); 687 retVal.add("UAC"); 688 retVal.add("EVN"); 689 retVal.add("PID"); 690 retVal.add("PD1"); 691 retVal.add("ARV"); 692 retVal.add("ROL"); 693 retVal.add("PV1"); 694 retVal.add("PV2"); 695 retVal.add("ARV2"); 696 retVal.add("ROL2"); 697 retVal.add("DB1"); 698 retVal.add("OBX"); 699 retVal.add("DG1"); 700 } 701 if ( "ADT_A16".equals(theStructure) ) { 702 retVal.add("MSH"); 703 retVal.add("SFT"); 704 retVal.add("UAC"); 705 retVal.add("EVN"); 706 retVal.add("PID"); 707 retVal.add("PD1"); 708 retVal.add("ARV"); 709 retVal.add("ROL"); 710 retVal.add("NK1"); 711 retVal.add("PV1"); 712 retVal.add("PV2"); 713 retVal.add("ARV2"); 714 retVal.add("ROL2"); 715 retVal.add("DB1"); 716 retVal.add("OBX"); 717 retVal.add("AL1"); 718 retVal.add("DG1"); 719 retVal.add("DRG"); 720 retVal.add("PROCEDURE"); 721 retVal.add("GT1"); 722 retVal.add("INSURANCE"); 723 retVal.add("ACC"); 724 } 725 if ( "ADT_A17".equals(theStructure) ) { 726 retVal.add("MSH"); 727 retVal.add("SFT"); 728 retVal.add("UAC"); 729 retVal.add("EVN"); 730 retVal.add("PID"); 731 retVal.add("PD1"); 732 retVal.add("PV1"); 733 retVal.add("PV2"); 734 retVal.add("DB1"); 735 retVal.add("OBX"); 736 retVal.add("PID2"); 737 retVal.add("PD12"); 738 retVal.add("PV12"); 739 retVal.add("PV22"); 740 retVal.add("DB12"); 741 retVal.add("OBX2"); 742 } 743 if ( "ADT_A18".equals(theStructure) ) { 744 retVal.add("MSH"); 745 retVal.add("SFT"); 746 retVal.add("EVN"); 747 retVal.add("PID"); 748 retVal.add("PD1"); 749 retVal.add("MRG"); 750 retVal.add("PV1"); 751 } 752 if ( "ADT_A20".equals(theStructure) ) { 753 retVal.add("MSH"); 754 retVal.add("SFT"); 755 retVal.add("UAC"); 756 retVal.add("EVN"); 757 retVal.add("NPU"); 758 } 759 if ( "ADT_A21".equals(theStructure) ) { 760 retVal.add("MSH"); 761 retVal.add("SFT"); 762 retVal.add("UAC"); 763 retVal.add("EVN"); 764 retVal.add("PID"); 765 retVal.add("PD1"); 766 retVal.add("PV1"); 767 retVal.add("PV2"); 768 retVal.add("DB1"); 769 retVal.add("OBX"); 770 } 771 if ( "ADT_A24".equals(theStructure) ) { 772 retVal.add("MSH"); 773 retVal.add("SFT"); 774 retVal.add("UAC"); 775 retVal.add("EVN"); 776 retVal.add("PID"); 777 retVal.add("PD1"); 778 retVal.add("PV1"); 779 retVal.add("DB1"); 780 retVal.add("PID2"); 781 retVal.add("PD12"); 782 retVal.add("PV12"); 783 retVal.add("DB12"); 784 } 785 if ( "ADT_A30".equals(theStructure) ) { 786 retVal.add("MSH"); 787 retVal.add("SFT"); 788 retVal.add("UAC"); 789 retVal.add("EVN"); 790 retVal.add("PID"); 791 retVal.add("PD1"); 792 retVal.add("ARV"); 793 retVal.add("MRG"); 794 } 795 if ( "ADT_A37".equals(theStructure) ) { 796 retVal.add("MSH"); 797 retVal.add("SFT"); 798 retVal.add("UAC"); 799 retVal.add("EVN"); 800 retVal.add("PID"); 801 retVal.add("PD1"); 802 retVal.add("PV1"); 803 retVal.add("DB1"); 804 retVal.add("PID2"); 805 retVal.add("PD12"); 806 retVal.add("PV12"); 807 retVal.add("DB12"); 808 } 809 if ( "ADT_A38".equals(theStructure) ) { 810 retVal.add("MSH"); 811 retVal.add("SFT"); 812 retVal.add("UAC"); 813 retVal.add("EVN"); 814 retVal.add("PID"); 815 retVal.add("PD1"); 816 retVal.add("PV1"); 817 retVal.add("PV2"); 818 retVal.add("DB1"); 819 retVal.add("OBX"); 820 retVal.add("DG1"); 821 retVal.add("DRG"); 822 } 823 if ( "ADT_A39".equals(theStructure) ) { 824 retVal.add("MSH"); 825 retVal.add("SFT"); 826 retVal.add("UAC"); 827 retVal.add("EVN"); 828 retVal.add("PATIENT"); 829 } 830 if ( "ADT_A43".equals(theStructure) ) { 831 retVal.add("MSH"); 832 retVal.add("SFT"); 833 retVal.add("UAC"); 834 retVal.add("EVN"); 835 retVal.add("PATIENT"); 836 } 837 if ( "ADT_A45".equals(theStructure) ) { 838 retVal.add("MSH"); 839 retVal.add("SFT"); 840 retVal.add("UAC"); 841 retVal.add("EVN"); 842 retVal.add("PID"); 843 retVal.add("PD1"); 844 retVal.add("MERGE_INFO"); 845 } 846 if ( "ADT_A50".equals(theStructure) ) { 847 retVal.add("MSH"); 848 retVal.add("SFT"); 849 retVal.add("UAC"); 850 retVal.add("EVN"); 851 retVal.add("PID"); 852 retVal.add("PD1"); 853 retVal.add("MRG"); 854 retVal.add("PV1"); 855 } 856 if ( "ADT_A52".equals(theStructure) ) { 857 retVal.add("MSH"); 858 retVal.add("SFT"); 859 retVal.add("UAC"); 860 retVal.add("EVN"); 861 retVal.add("PID"); 862 retVal.add("PD1"); 863 retVal.add("PV1"); 864 retVal.add("PV2"); 865 } 866 if ( "ADT_A54".equals(theStructure) ) { 867 retVal.add("MSH"); 868 retVal.add("SFT"); 869 retVal.add("UAC"); 870 retVal.add("EVN"); 871 retVal.add("PID"); 872 retVal.add("PD1"); 873 retVal.add("ROL"); 874 retVal.add("PV1"); 875 retVal.add("PV2"); 876 retVal.add("ROL2"); 877 } 878 if ( "ADT_A60".equals(theStructure) ) { 879 retVal.add("MSH"); 880 retVal.add("SFT"); 881 retVal.add("UAC"); 882 retVal.add("EVN"); 883 retVal.add("PID"); 884 retVal.add("ARV"); 885 retVal.add("PV1"); 886 retVal.add("PV2"); 887 retVal.add("ARV2"); 888 retVal.add("IAM"); 889 } 890 if ( "ADT_A61".equals(theStructure) ) { 891 retVal.add("MSH"); 892 retVal.add("SFT"); 893 retVal.add("UAC"); 894 retVal.add("EVN"); 895 retVal.add("PID"); 896 retVal.add("PD1"); 897 retVal.add("ROL"); 898 retVal.add("PV1"); 899 retVal.add("ROL2"); 900 retVal.add("PV2"); 901 } 902 return retVal; 903 } 904 905 /** 906 * Returns "2.6" 907 */ 908 public String getVersion() { 909 return "2.6"; 910 } 911 912 913 914 915 /** 916 * <p> 917 * Returns 918 * MSH () - creates it if necessary 919 * </p> 920 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 921 * 922 */ 923 public MSH getMSH() { 924 return getTyped("MSH", MSH.class); 925 } 926 927 928 929 930 931 /** 932 * <p> 933 * Returns 934 * the first repetition of 935 * SFT () - creates it if necessary 936 * </p> 937 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 938 * 939 */ 940 public SFT getSFT() { 941 return getTyped("SFT", SFT.class); 942 } 943 944 945 /** 946 * <p> 947 * Returns a specific repetition of 948 * SFT () - creates it if necessary 949 * </p> 950 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 951 * 952 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 953 * @throws HL7Exception if the repetition requested is more than one 954 * greater than the number of existing repetitions. 955 */ 956 public SFT getSFT(int rep) { 957 return getTyped("SFT", rep, SFT.class); 958 } 959 960 /** 961 * <p> 962 * Returns the number of existing repetitions of SFT 963 * </p> 964 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 965 */ 966 public int getSFTReps() { 967 return getReps("SFT"); 968 } 969 970 /** 971 * <p> 972 * Returns a non-modifiable List containing all current existing repetitions of SFT. 973 * <p> 974 * <p> 975 * Note that unlike {@link #getSFT()}, this method will not create any reps 976 * if none are already present, so an empty list may be returned. 977 * </p> 978 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 979 */ 980 public java.util.List<SFT> getSFTAll() throws HL7Exception { 981 return getAllAsList("SFT", SFT.class); 982 } 983 984 /** 985 * <p> 986 * Inserts a specific repetition of SFT () 987 * </p> 988 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 989 * 990 * @see AbstractGroup#insertRepetition(Structure, int) 991 */ 992 public void insertSFT(SFT structure, int rep) throws HL7Exception { 993 super.insertRepetition( "SFT", structure, rep); 994 } 995 996 997 /** 998 * <p> 999 * Inserts a specific repetition of SFT () 1000 * </p> 1001 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1002 * 1003 * @see AbstractGroup#insertRepetition(Structure, int) 1004 */ 1005 public SFT insertSFT(int rep) throws HL7Exception { 1006 return (SFT)super.insertRepetition("SFT", rep); 1007 } 1008 1009 1010 /** 1011 * <p> 1012 * Removes a specific repetition of SFT () 1013 * </p> 1014 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1015 * 1016 * @see AbstractGroup#removeRepetition(String, int) 1017 */ 1018 public SFT removeSFT(int rep) throws HL7Exception { 1019 return (SFT)super.removeRepetition("SFT", rep); 1020 } 1021 1022 1023 1024 1025 /** 1026 * <p> 1027 * Returns 1028 * UAC () - creates it if necessary 1029 * </p> 1030 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1031 * 1032 */ 1033 public UAC getUAC() { 1034 return getTyped("UAC", UAC.class); 1035 } 1036 1037 1038 1039 1040 1041 /** 1042 * <p> 1043 * Returns 1044 * EVN () - creates it if necessary 1045 * </p> 1046 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A40, ADT_A41, ADT_A42, ADT_A44, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1047 * 1048 */ 1049 public EVN getEVN() { 1050 return getTyped("EVN", EVN.class); 1051 } 1052 1053 1054 1055 1056 1057 /** 1058 * <p> 1059 * Returns 1060 * PID () - creates it if necessary 1061 * </p> 1062 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1063 * 1064 */ 1065 public PID getPID() { 1066 return getTyped("PID", PID.class); 1067 } 1068 1069 1070 1071 1072 1073 /** 1074 * <p> 1075 * Returns 1076 * PD1 () - creates it if necessary 1077 * </p> 1078 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1079 * 1080 */ 1081 public PD1 getPD1() { 1082 return getTyped("PD1", PD1.class); 1083 } 1084 1085 1086 1087 1088 1089 /** 1090 * <p> 1091 * Returns 1092 * the first repetition of 1093 * ARV () - creates it if necessary 1094 * </p> 1095 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1096 * 1097 */ 1098 public ARV getARV() { 1099 return getTyped("ARV", ARV.class); 1100 } 1101 1102 1103 /** 1104 * <p> 1105 * Returns a specific repetition of 1106 * ARV () - creates it if necessary 1107 * </p> 1108 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1109 * 1110 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1111 * @throws HL7Exception if the repetition requested is more than one 1112 * greater than the number of existing repetitions. 1113 */ 1114 public ARV getARV(int rep) { 1115 return getTyped("ARV", rep, ARV.class); 1116 } 1117 1118 /** 1119 * <p> 1120 * Returns the number of existing repetitions of ARV 1121 * </p> 1122 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1123 */ 1124 public int getARVReps() { 1125 return getReps("ARV"); 1126 } 1127 1128 /** 1129 * <p> 1130 * Returns a non-modifiable List containing all current existing repetitions of ARV. 1131 * <p> 1132 * <p> 1133 * Note that unlike {@link #getARV()}, this method will not create any reps 1134 * if none are already present, so an empty list may be returned. 1135 * </p> 1136 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1137 */ 1138 public java.util.List<ARV> getARVAll() throws HL7Exception { 1139 return getAllAsList("ARV", ARV.class); 1140 } 1141 1142 /** 1143 * <p> 1144 * Inserts a specific repetition of ARV () 1145 * </p> 1146 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1147 * 1148 * @see AbstractGroup#insertRepetition(Structure, int) 1149 */ 1150 public void insertARV(ARV structure, int rep) throws HL7Exception { 1151 super.insertRepetition( "ARV", structure, rep); 1152 } 1153 1154 1155 /** 1156 * <p> 1157 * Inserts a specific repetition of ARV () 1158 * </p> 1159 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1160 * 1161 * @see AbstractGroup#insertRepetition(Structure, int) 1162 */ 1163 public ARV insertARV(int rep) throws HL7Exception { 1164 return (ARV)super.insertRepetition("ARV", rep); 1165 } 1166 1167 1168 /** 1169 * <p> 1170 * Removes a specific repetition of ARV () 1171 * </p> 1172 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49] 1173 * 1174 * @see AbstractGroup#removeRepetition(String, int) 1175 */ 1176 public ARV removeARV(int rep) throws HL7Exception { 1177 return (ARV)super.removeRepetition("ARV", rep); 1178 } 1179 1180 1181 1182 1183 /** 1184 * <p> 1185 * Returns 1186 * the first repetition of 1187 * ROL () - creates it if necessary 1188 * </p> 1189 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1190 * 1191 */ 1192 public ROL getROL() { 1193 return getTyped("ROL", ROL.class); 1194 } 1195 1196 1197 /** 1198 * <p> 1199 * Returns a specific repetition of 1200 * ROL () - creates it if necessary 1201 * </p> 1202 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1203 * 1204 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1205 * @throws HL7Exception if the repetition requested is more than one 1206 * greater than the number of existing repetitions. 1207 */ 1208 public ROL getROL(int rep) { 1209 return getTyped("ROL", rep, ROL.class); 1210 } 1211 1212 /** 1213 * <p> 1214 * Returns the number of existing repetitions of ROL 1215 * </p> 1216 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1217 */ 1218 public int getROLReps() { 1219 return getReps("ROL"); 1220 } 1221 1222 /** 1223 * <p> 1224 * Returns a non-modifiable List containing all current existing repetitions of ROL. 1225 * <p> 1226 * <p> 1227 * Note that unlike {@link #getROL()}, this method will not create any reps 1228 * if none are already present, so an empty list may be returned. 1229 * </p> 1230 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1231 */ 1232 public java.util.List<ROL> getROLAll() throws HL7Exception { 1233 return getAllAsList("ROL", ROL.class); 1234 } 1235 1236 /** 1237 * <p> 1238 * Inserts a specific repetition of ROL () 1239 * </p> 1240 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1241 * 1242 * @see AbstractGroup#insertRepetition(Structure, int) 1243 */ 1244 public void insertROL(ROL structure, int rep) throws HL7Exception { 1245 super.insertRepetition( "ROL", structure, rep); 1246 } 1247 1248 1249 /** 1250 * <p> 1251 * Inserts a specific repetition of ROL () 1252 * </p> 1253 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1254 * 1255 * @see AbstractGroup#insertRepetition(Structure, int) 1256 */ 1257 public ROL insertROL(int rep) throws HL7Exception { 1258 return (ROL)super.insertRepetition("ROL", rep); 1259 } 1260 1261 1262 /** 1263 * <p> 1264 * Removes a specific repetition of ROL () 1265 * </p> 1266 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1267 * 1268 * @see AbstractGroup#removeRepetition(String, int) 1269 */ 1270 public ROL removeROL(int rep) throws HL7Exception { 1271 return (ROL)super.removeRepetition("ROL", rep); 1272 } 1273 1274 1275 1276 1277 /** 1278 * <p> 1279 * Returns 1280 * MRG () - creates it if necessary 1281 * </p> 1282 * Used for the following structures: [ADT_A07, ADT_A34, ADT_A35, ADT_A36, ADT_A46, ADT_A47, ADT_A48, ADT_A49, ADT_A51] 1283 * 1284 */ 1285 public MRG getMRG() { 1286 return getTyped("MRG", MRG.class); 1287 } 1288 1289 1290 1291 1292 1293 /** 1294 * <p> 1295 * Returns 1296 * the first repetition of 1297 * NK1 () - creates it if necessary 1298 * </p> 1299 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1300 * 1301 */ 1302 public NK1 getNK1() { 1303 return getTyped("NK1", NK1.class); 1304 } 1305 1306 1307 /** 1308 * <p> 1309 * Returns a specific repetition of 1310 * NK1 () - creates it if necessary 1311 * </p> 1312 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1313 * 1314 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1315 * @throws HL7Exception if the repetition requested is more than one 1316 * greater than the number of existing repetitions. 1317 */ 1318 public NK1 getNK1(int rep) { 1319 return getTyped("NK1", rep, NK1.class); 1320 } 1321 1322 /** 1323 * <p> 1324 * Returns the number of existing repetitions of NK1 1325 * </p> 1326 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1327 */ 1328 public int getNK1Reps() { 1329 return getReps("NK1"); 1330 } 1331 1332 /** 1333 * <p> 1334 * Returns a non-modifiable List containing all current existing repetitions of NK1. 1335 * <p> 1336 * <p> 1337 * Note that unlike {@link #getNK1()}, this method will not create any reps 1338 * if none are already present, so an empty list may be returned. 1339 * </p> 1340 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1341 */ 1342 public java.util.List<NK1> getNK1All() throws HL7Exception { 1343 return getAllAsList("NK1", NK1.class); 1344 } 1345 1346 /** 1347 * <p> 1348 * Inserts a specific repetition of NK1 () 1349 * </p> 1350 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1351 * 1352 * @see AbstractGroup#insertRepetition(Structure, int) 1353 */ 1354 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 1355 super.insertRepetition( "NK1", structure, rep); 1356 } 1357 1358 1359 /** 1360 * <p> 1361 * Inserts a specific repetition of NK1 () 1362 * </p> 1363 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1364 * 1365 * @see AbstractGroup#insertRepetition(Structure, int) 1366 */ 1367 public NK1 insertNK1(int rep) throws HL7Exception { 1368 return (NK1)super.insertRepetition("NK1", rep); 1369 } 1370 1371 1372 /** 1373 * <p> 1374 * Removes a specific repetition of NK1 () 1375 * </p> 1376 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1377 * 1378 * @see AbstractGroup#removeRepetition(String, int) 1379 */ 1380 public NK1 removeNK1(int rep) throws HL7Exception { 1381 return (NK1)super.removeRepetition("NK1", rep); 1382 } 1383 1384 1385 1386 1387 /** 1388 * <p> 1389 * Returns 1390 * PV1 () - creates it if necessary 1391 * </p> 1392 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A51, ADT_A53, ADT_A55, ADT_A62] 1393 * 1394 */ 1395 public PV1 getPV1() { 1396 return getTyped("PV1", PV1.class); 1397 } 1398 1399 1400 1401 1402 1403 /** 1404 * <p> 1405 * Returns 1406 * PV2 () - creates it if necessary 1407 * </p> 1408 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33, ADT_A53, ADT_A55, ADT_A62] 1409 * 1410 */ 1411 public PV2 getPV2() { 1412 return getTyped("PV2", PV2.class); 1413 } 1414 1415 1416 1417 1418 1419 /** 1420 * <p> 1421 * Returns 1422 * the first repetition of 1423 * ARV2 () - creates it if necessary 1424 * </p> 1425 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1426 * 1427 */ 1428 public ARV getARV2() { 1429 return getTyped("ARV2", ARV.class); 1430 } 1431 1432 1433 /** 1434 * <p> 1435 * Returns a specific repetition of 1436 * ARV2 () - creates it if necessary 1437 * </p> 1438 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1439 * 1440 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1441 * @throws HL7Exception if the repetition requested is more than one 1442 * greater than the number of existing repetitions. 1443 */ 1444 public ARV getARV2(int rep) { 1445 return getTyped("ARV2", rep, ARV.class); 1446 } 1447 1448 /** 1449 * <p> 1450 * Returns the number of existing repetitions of ARV2 1451 * </p> 1452 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1453 */ 1454 public int getARV2Reps() { 1455 return getReps("ARV2"); 1456 } 1457 1458 /** 1459 * <p> 1460 * Returns a non-modifiable List containing all current existing repetitions of ARV2. 1461 * <p> 1462 * <p> 1463 * Note that unlike {@link #getARV2()}, this method will not create any reps 1464 * if none are already present, so an empty list may be returned. 1465 * </p> 1466 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1467 */ 1468 public java.util.List<ARV> getARV2All() throws HL7Exception { 1469 return getAllAsList("ARV2", ARV.class); 1470 } 1471 1472 /** 1473 * <p> 1474 * Inserts a specific repetition of ARV2 () 1475 * </p> 1476 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1477 * 1478 * @see AbstractGroup#insertRepetition(Structure, int) 1479 */ 1480 public void insertARV2(ARV structure, int rep) throws HL7Exception { 1481 super.insertRepetition( "ARV2", structure, rep); 1482 } 1483 1484 1485 /** 1486 * <p> 1487 * Inserts a specific repetition of ARV2 () 1488 * </p> 1489 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1490 * 1491 * @see AbstractGroup#insertRepetition(Structure, int) 1492 */ 1493 public ARV insertARV2(int rep) throws HL7Exception { 1494 return (ARV)super.insertRepetition("ARV2", rep); 1495 } 1496 1497 1498 /** 1499 * <p> 1500 * Removes a specific repetition of ARV2 () 1501 * </p> 1502 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1503 * 1504 * @see AbstractGroup#removeRepetition(String, int) 1505 */ 1506 public ARV removeARV2(int rep) throws HL7Exception { 1507 return (ARV)super.removeRepetition("ARV2", rep); 1508 } 1509 1510 1511 1512 1513 /** 1514 * <p> 1515 * Returns 1516 * the first repetition of 1517 * ROL2 () - creates it if necessary 1518 * </p> 1519 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1520 * 1521 */ 1522 public ROL getROL2() { 1523 return getTyped("ROL2", ROL.class); 1524 } 1525 1526 1527 /** 1528 * <p> 1529 * Returns a specific repetition of 1530 * ROL2 () - creates it if necessary 1531 * </p> 1532 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1533 * 1534 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1535 * @throws HL7Exception if the repetition requested is more than one 1536 * greater than the number of existing repetitions. 1537 */ 1538 public ROL getROL2(int rep) { 1539 return getTyped("ROL2", rep, ROL.class); 1540 } 1541 1542 /** 1543 * <p> 1544 * Returns the number of existing repetitions of ROL2 1545 * </p> 1546 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1547 */ 1548 public int getROL2Reps() { 1549 return getReps("ROL2"); 1550 } 1551 1552 /** 1553 * <p> 1554 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 1555 * <p> 1556 * <p> 1557 * Note that unlike {@link #getROL2()}, this method will not create any reps 1558 * if none are already present, so an empty list may be returned. 1559 * </p> 1560 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1561 */ 1562 public java.util.List<ROL> getROL2All() throws HL7Exception { 1563 return getAllAsList("ROL2", ROL.class); 1564 } 1565 1566 /** 1567 * <p> 1568 * Inserts a specific repetition of ROL2 () 1569 * </p> 1570 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1571 * 1572 * @see AbstractGroup#insertRepetition(Structure, int) 1573 */ 1574 public void insertROL2(ROL structure, int rep) throws HL7Exception { 1575 super.insertRepetition( "ROL2", structure, rep); 1576 } 1577 1578 1579 /** 1580 * <p> 1581 * Inserts a specific repetition of ROL2 () 1582 * </p> 1583 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1584 * 1585 * @see AbstractGroup#insertRepetition(Structure, int) 1586 */ 1587 public ROL insertROL2(int rep) throws HL7Exception { 1588 return (ROL)super.insertRepetition("ROL2", rep); 1589 } 1590 1591 1592 /** 1593 * <p> 1594 * Removes a specific repetition of ROL2 () 1595 * </p> 1596 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31, ADT_A55, ADT_A62] 1597 * 1598 * @see AbstractGroup#removeRepetition(String, int) 1599 */ 1600 public ROL removeROL2(int rep) throws HL7Exception { 1601 return (ROL)super.removeRepetition("ROL2", rep); 1602 } 1603 1604 1605 1606 1607 /** 1608 * <p> 1609 * Returns 1610 * the first repetition of 1611 * DB1 () - creates it if necessary 1612 * </p> 1613 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1614 * 1615 */ 1616 public DB1 getDB1() { 1617 return getTyped("DB1", DB1.class); 1618 } 1619 1620 1621 /** 1622 * <p> 1623 * Returns a specific repetition of 1624 * DB1 () - creates it if necessary 1625 * </p> 1626 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1627 * 1628 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1629 * @throws HL7Exception if the repetition requested is more than one 1630 * greater than the number of existing repetitions. 1631 */ 1632 public DB1 getDB1(int rep) { 1633 return getTyped("DB1", rep, DB1.class); 1634 } 1635 1636 /** 1637 * <p> 1638 * Returns the number of existing repetitions of DB1 1639 * </p> 1640 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1641 */ 1642 public int getDB1Reps() { 1643 return getReps("DB1"); 1644 } 1645 1646 /** 1647 * <p> 1648 * Returns a non-modifiable List containing all current existing repetitions of DB1. 1649 * <p> 1650 * <p> 1651 * Note that unlike {@link #getDB1()}, this method will not create any reps 1652 * if none are already present, so an empty list may be returned. 1653 * </p> 1654 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1655 */ 1656 public java.util.List<DB1> getDB1All() throws HL7Exception { 1657 return getAllAsList("DB1", DB1.class); 1658 } 1659 1660 /** 1661 * <p> 1662 * Inserts a specific repetition of DB1 () 1663 * </p> 1664 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1665 * 1666 * @see AbstractGroup#insertRepetition(Structure, int) 1667 */ 1668 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 1669 super.insertRepetition( "DB1", structure, rep); 1670 } 1671 1672 1673 /** 1674 * <p> 1675 * Inserts a specific repetition of DB1 () 1676 * </p> 1677 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1678 * 1679 * @see AbstractGroup#insertRepetition(Structure, int) 1680 */ 1681 public DB1 insertDB1(int rep) throws HL7Exception { 1682 return (DB1)super.insertRepetition("DB1", rep); 1683 } 1684 1685 1686 /** 1687 * <p> 1688 * Removes a specific repetition of DB1 () 1689 * </p> 1690 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1691 * 1692 * @see AbstractGroup#removeRepetition(String, int) 1693 */ 1694 public DB1 removeDB1(int rep) throws HL7Exception { 1695 return (DB1)super.removeRepetition("DB1", rep); 1696 } 1697 1698 1699 1700 1701 /** 1702 * <p> 1703 * Returns 1704 * the first repetition of 1705 * OBX () - creates it if necessary 1706 * </p> 1707 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1708 * 1709 */ 1710 public OBX getOBX() { 1711 return getTyped("OBX", OBX.class); 1712 } 1713 1714 1715 /** 1716 * <p> 1717 * Returns a specific repetition of 1718 * OBX () - creates it if necessary 1719 * </p> 1720 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1721 * 1722 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1723 * @throws HL7Exception if the repetition requested is more than one 1724 * greater than the number of existing repetitions. 1725 */ 1726 public OBX getOBX(int rep) { 1727 return getTyped("OBX", rep, OBX.class); 1728 } 1729 1730 /** 1731 * <p> 1732 * Returns the number of existing repetitions of OBX 1733 * </p> 1734 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1735 */ 1736 public int getOBXReps() { 1737 return getReps("OBX"); 1738 } 1739 1740 /** 1741 * <p> 1742 * Returns a non-modifiable List containing all current existing repetitions of OBX. 1743 * <p> 1744 * <p> 1745 * Note that unlike {@link #getOBX()}, this method will not create any reps 1746 * if none are already present, so an empty list may be returned. 1747 * </p> 1748 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1749 */ 1750 public java.util.List<OBX> getOBXAll() throws HL7Exception { 1751 return getAllAsList("OBX", OBX.class); 1752 } 1753 1754 /** 1755 * <p> 1756 * Inserts a specific repetition of OBX () 1757 * </p> 1758 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1759 * 1760 * @see AbstractGroup#insertRepetition(Structure, int) 1761 */ 1762 public void insertOBX(OBX structure, int rep) throws HL7Exception { 1763 super.insertRepetition( "OBX", structure, rep); 1764 } 1765 1766 1767 /** 1768 * <p> 1769 * Inserts a specific repetition of OBX () 1770 * </p> 1771 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1772 * 1773 * @see AbstractGroup#insertRepetition(Structure, int) 1774 */ 1775 public OBX insertOBX(int rep) throws HL7Exception { 1776 return (OBX)super.insertRepetition("OBX", rep); 1777 } 1778 1779 1780 /** 1781 * <p> 1782 * Removes a specific repetition of OBX () 1783 * </p> 1784 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A22, ADT_A23, ADT_A25, ADT_A26, ADT_A27, ADT_A28, ADT_A29, ADT_A31, ADT_A32, ADT_A33] 1785 * 1786 * @see AbstractGroup#removeRepetition(String, int) 1787 */ 1788 public OBX removeOBX(int rep) throws HL7Exception { 1789 return (OBX)super.removeRepetition("OBX", rep); 1790 } 1791 1792 1793 1794 1795 /** 1796 * <p> 1797 * Returns 1798 * the first repetition of 1799 * AL1 () - creates it if necessary 1800 * </p> 1801 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1802 * 1803 */ 1804 public AL1 getAL1() { 1805 return getTyped("AL1", AL1.class); 1806 } 1807 1808 1809 /** 1810 * <p> 1811 * Returns a specific repetition of 1812 * AL1 () - creates it if necessary 1813 * </p> 1814 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1815 * 1816 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1817 * @throws HL7Exception if the repetition requested is more than one 1818 * greater than the number of existing repetitions. 1819 */ 1820 public AL1 getAL1(int rep) { 1821 return getTyped("AL1", rep, AL1.class); 1822 } 1823 1824 /** 1825 * <p> 1826 * Returns the number of existing repetitions of AL1 1827 * </p> 1828 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1829 */ 1830 public int getAL1Reps() { 1831 return getReps("AL1"); 1832 } 1833 1834 /** 1835 * <p> 1836 * Returns a non-modifiable List containing all current existing repetitions of AL1. 1837 * <p> 1838 * <p> 1839 * Note that unlike {@link #getAL1()}, this method will not create any reps 1840 * if none are already present, so an empty list may be returned. 1841 * </p> 1842 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1843 */ 1844 public java.util.List<AL1> getAL1All() throws HL7Exception { 1845 return getAllAsList("AL1", AL1.class); 1846 } 1847 1848 /** 1849 * <p> 1850 * Inserts a specific repetition of AL1 () 1851 * </p> 1852 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1853 * 1854 * @see AbstractGroup#insertRepetition(Structure, int) 1855 */ 1856 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 1857 super.insertRepetition( "AL1", structure, rep); 1858 } 1859 1860 1861 /** 1862 * <p> 1863 * Inserts a specific repetition of AL1 () 1864 * </p> 1865 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1866 * 1867 * @see AbstractGroup#insertRepetition(Structure, int) 1868 */ 1869 public AL1 insertAL1(int rep) throws HL7Exception { 1870 return (AL1)super.insertRepetition("AL1", rep); 1871 } 1872 1873 1874 /** 1875 * <p> 1876 * Removes a specific repetition of AL1 () 1877 * </p> 1878 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1879 * 1880 * @see AbstractGroup#removeRepetition(String, int) 1881 */ 1882 public AL1 removeAL1(int rep) throws HL7Exception { 1883 return (AL1)super.removeRepetition("AL1", rep); 1884 } 1885 1886 1887 1888 1889 /** 1890 * <p> 1891 * Returns 1892 * the first repetition of 1893 * DG1 () - creates it if necessary 1894 * </p> 1895 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1896 * 1897 */ 1898 public DG1 getDG1() { 1899 return getTyped("DG1", DG1.class); 1900 } 1901 1902 1903 /** 1904 * <p> 1905 * Returns a specific repetition of 1906 * DG1 () - creates it if necessary 1907 * </p> 1908 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1909 * 1910 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1911 * @throws HL7Exception if the repetition requested is more than one 1912 * greater than the number of existing repetitions. 1913 */ 1914 public DG1 getDG1(int rep) { 1915 return getTyped("DG1", rep, DG1.class); 1916 } 1917 1918 /** 1919 * <p> 1920 * Returns the number of existing repetitions of DG1 1921 * </p> 1922 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1923 */ 1924 public int getDG1Reps() { 1925 return getReps("DG1"); 1926 } 1927 1928 /** 1929 * <p> 1930 * Returns a non-modifiable List containing all current existing repetitions of DG1. 1931 * <p> 1932 * <p> 1933 * Note that unlike {@link #getDG1()}, this method will not create any reps 1934 * if none are already present, so an empty list may be returned. 1935 * </p> 1936 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1937 */ 1938 public java.util.List<DG1> getDG1All() throws HL7Exception { 1939 return getAllAsList("DG1", DG1.class); 1940 } 1941 1942 /** 1943 * <p> 1944 * Inserts a specific repetition of DG1 () 1945 * </p> 1946 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1947 * 1948 * @see AbstractGroup#insertRepetition(Structure, int) 1949 */ 1950 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 1951 super.insertRepetition( "DG1", structure, rep); 1952 } 1953 1954 1955 /** 1956 * <p> 1957 * Inserts a specific repetition of DG1 () 1958 * </p> 1959 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1960 * 1961 * @see AbstractGroup#insertRepetition(Structure, int) 1962 */ 1963 public DG1 insertDG1(int rep) throws HL7Exception { 1964 return (DG1)super.insertRepetition("DG1", rep); 1965 } 1966 1967 1968 /** 1969 * <p> 1970 * Removes a specific repetition of DG1 () 1971 * </p> 1972 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A10, ADT_A11, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1973 * 1974 * @see AbstractGroup#removeRepetition(String, int) 1975 */ 1976 public DG1 removeDG1(int rep) throws HL7Exception { 1977 return (DG1)super.removeRepetition("DG1", rep); 1978 } 1979 1980 1981 1982 1983 /** 1984 * <p> 1985 * Returns 1986 * DRG () - creates it if necessary 1987 * </p> 1988 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 1989 * 1990 */ 1991 public DRG getDRG() { 1992 return getTyped("DRG", DRG.class); 1993 } 1994 1995 1996 1997 1998 1999 /** 2000 * <p> 2001 * Returns 2002 * the first repetition of 2003 * PROCEDURE () - creates it if necessary 2004 * </p> 2005 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2006 * 2007 */ 2008 public ADT_AXX_PROCEDURE getPROCEDURE() { 2009 return getTyped("PROCEDURE", ADT_AXX_PROCEDURE.class); 2010 } 2011 2012 2013 /** 2014 * <p> 2015 * Returns a specific repetition of 2016 * PROCEDURE () - creates it if necessary 2017 * </p> 2018 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2019 * 2020 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2021 * @throws HL7Exception if the repetition requested is more than one 2022 * greater than the number of existing repetitions. 2023 */ 2024 public ADT_AXX_PROCEDURE getPROCEDURE(int rep) { 2025 return getTyped("PROCEDURE", rep, ADT_AXX_PROCEDURE.class); 2026 } 2027 2028 /** 2029 * <p> 2030 * Returns the number of existing repetitions of PROCEDURE 2031 * </p> 2032 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2033 */ 2034 public int getPROCEDUREReps() { 2035 return getReps("PROCEDURE"); 2036 } 2037 2038 /** 2039 * <p> 2040 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 2041 * <p> 2042 * <p> 2043 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 2044 * if none are already present, so an empty list may be returned. 2045 * </p> 2046 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2047 */ 2048 public java.util.List<ADT_AXX_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 2049 return getAllAsList("PROCEDURE", ADT_AXX_PROCEDURE.class); 2050 } 2051 2052 /** 2053 * <p> 2054 * Inserts a specific repetition of PROCEDURE () 2055 * </p> 2056 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2057 * 2058 * @see AbstractGroup#insertRepetition(Structure, int) 2059 */ 2060 public void insertPROCEDURE(ADT_AXX_PROCEDURE structure, int rep) throws HL7Exception { 2061 super.insertRepetition( "PROCEDURE", structure, rep); 2062 } 2063 2064 2065 /** 2066 * <p> 2067 * Inserts a specific repetition of PROCEDURE () 2068 * </p> 2069 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2070 * 2071 * @see AbstractGroup#insertRepetition(Structure, int) 2072 */ 2073 public ADT_AXX_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 2074 return (ADT_AXX_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 2075 } 2076 2077 2078 /** 2079 * <p> 2080 * Removes a specific repetition of PROCEDURE () 2081 * </p> 2082 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2083 * 2084 * @see AbstractGroup#removeRepetition(String, int) 2085 */ 2086 public ADT_AXX_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 2087 return (ADT_AXX_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 2088 } 2089 2090 2091 2092 2093 /** 2094 * <p> 2095 * Returns 2096 * the first repetition of 2097 * GT1 () - creates it if necessary 2098 * </p> 2099 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2100 * 2101 */ 2102 public GT1 getGT1() { 2103 return getTyped("GT1", GT1.class); 2104 } 2105 2106 2107 /** 2108 * <p> 2109 * Returns a specific repetition of 2110 * GT1 () - creates it if necessary 2111 * </p> 2112 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2113 * 2114 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2115 * @throws HL7Exception if the repetition requested is more than one 2116 * greater than the number of existing repetitions. 2117 */ 2118 public GT1 getGT1(int rep) { 2119 return getTyped("GT1", rep, GT1.class); 2120 } 2121 2122 /** 2123 * <p> 2124 * Returns the number of existing repetitions of GT1 2125 * </p> 2126 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2127 */ 2128 public int getGT1Reps() { 2129 return getReps("GT1"); 2130 } 2131 2132 /** 2133 * <p> 2134 * Returns a non-modifiable List containing all current existing repetitions of GT1. 2135 * <p> 2136 * <p> 2137 * Note that unlike {@link #getGT1()}, this method will not create any reps 2138 * if none are already present, so an empty list may be returned. 2139 * </p> 2140 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2141 */ 2142 public java.util.List<GT1> getGT1All() throws HL7Exception { 2143 return getAllAsList("GT1", GT1.class); 2144 } 2145 2146 /** 2147 * <p> 2148 * Inserts a specific repetition of GT1 () 2149 * </p> 2150 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2151 * 2152 * @see AbstractGroup#insertRepetition(Structure, int) 2153 */ 2154 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 2155 super.insertRepetition( "GT1", structure, rep); 2156 } 2157 2158 2159 /** 2160 * <p> 2161 * Inserts a specific repetition of GT1 () 2162 * </p> 2163 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2164 * 2165 * @see AbstractGroup#insertRepetition(Structure, int) 2166 */ 2167 public GT1 insertGT1(int rep) throws HL7Exception { 2168 return (GT1)super.insertRepetition("GT1", rep); 2169 } 2170 2171 2172 /** 2173 * <p> 2174 * Removes a specific repetition of GT1 () 2175 * </p> 2176 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2177 * 2178 * @see AbstractGroup#removeRepetition(String, int) 2179 */ 2180 public GT1 removeGT1(int rep) throws HL7Exception { 2181 return (GT1)super.removeRepetition("GT1", rep); 2182 } 2183 2184 2185 2186 2187 /** 2188 * <p> 2189 * Returns 2190 * the first repetition of 2191 * INSURANCE () - creates it if necessary 2192 * </p> 2193 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2194 * 2195 */ 2196 public ADT_AXX_INSURANCE getINSURANCE() { 2197 return getTyped("INSURANCE", ADT_AXX_INSURANCE.class); 2198 } 2199 2200 2201 /** 2202 * <p> 2203 * Returns a specific repetition of 2204 * INSURANCE () - creates it if necessary 2205 * </p> 2206 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2207 * 2208 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2209 * @throws HL7Exception if the repetition requested is more than one 2210 * greater than the number of existing repetitions. 2211 */ 2212 public ADT_AXX_INSURANCE getINSURANCE(int rep) { 2213 return getTyped("INSURANCE", rep, ADT_AXX_INSURANCE.class); 2214 } 2215 2216 /** 2217 * <p> 2218 * Returns the number of existing repetitions of INSURANCE 2219 * </p> 2220 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2221 */ 2222 public int getINSURANCEReps() { 2223 return getReps("INSURANCE"); 2224 } 2225 2226 /** 2227 * <p> 2228 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 2229 * <p> 2230 * <p> 2231 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 2232 * if none are already present, so an empty list may be returned. 2233 * </p> 2234 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2235 */ 2236 public java.util.List<ADT_AXX_INSURANCE> getINSURANCEAll() throws HL7Exception { 2237 return getAllAsList("INSURANCE", ADT_AXX_INSURANCE.class); 2238 } 2239 2240 /** 2241 * <p> 2242 * Inserts a specific repetition of INSURANCE () 2243 * </p> 2244 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2245 * 2246 * @see AbstractGroup#insertRepetition(Structure, int) 2247 */ 2248 public void insertINSURANCE(ADT_AXX_INSURANCE structure, int rep) throws HL7Exception { 2249 super.insertRepetition( "INSURANCE", structure, rep); 2250 } 2251 2252 2253 /** 2254 * <p> 2255 * Inserts a specific repetition of INSURANCE () 2256 * </p> 2257 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2258 * 2259 * @see AbstractGroup#insertRepetition(Structure, int) 2260 */ 2261 public ADT_AXX_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 2262 return (ADT_AXX_INSURANCE)super.insertRepetition("INSURANCE", rep); 2263 } 2264 2265 2266 /** 2267 * <p> 2268 * Removes a specific repetition of INSURANCE () 2269 * </p> 2270 * Used for the following structures: [ADT_A13, ADT_A04, ADT_A08, ADT_A14, ADT_A31, ADT_A28, ADT_A07] 2271 * 2272 * @see AbstractGroup#removeRepetition(String, int) 2273 */ 2274 public ADT_AXX_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 2275 return (ADT_AXX_INSURANCE)super.removeRepetition("INSURANCE", rep); 2276 } 2277 2278 2279 2280 2281 /** 2282 * <p> 2283 * Returns 2284 * ACC () - creates it if necessary 2285 * </p> 2286 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2287 * 2288 */ 2289 public ACC getACC() { 2290 return getTyped("ACC", ACC.class); 2291 } 2292 2293 2294 2295 2296 2297 /** 2298 * <p> 2299 * Returns 2300 * UB1 () - creates it if necessary 2301 * </p> 2302 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2303 * 2304 */ 2305 public UB1 getUB1() { 2306 return getTyped("UB1", UB1.class); 2307 } 2308 2309 2310 2311 2312 2313 /** 2314 * <p> 2315 * Returns 2316 * UB2 () - creates it if necessary 2317 * </p> 2318 * Used for the following structures: [ADT_A04, ADT_A07, ADT_A08, ADT_A13, ADT_A14, ADT_A28, ADT_A31] 2319 * 2320 */ 2321 public UB2 getUB2() { 2322 return getTyped("UB2", UB2.class); 2323 } 2324 2325 2326 2327 2328 2329 /** 2330 * <p> 2331 * Returns 2332 * PDA () - creates it if necessary 2333 * </p> 2334 * Used for the following structures: [ADT_A04, ADT_A08, ADT_A13] 2335 * 2336 */ 2337 public PDA getPDA() { 2338 return getTyped("PDA", PDA.class); 2339 } 2340 2341 2342 2343 2344 2345 /** 2346 * <p> 2347 * Returns 2348 * PID2 () - creates it if necessary 2349 * </p> 2350 * 2351 * 2352 */ 2353 public PID getPID2() { 2354 return getTyped("PID2", PID.class); 2355 } 2356 2357 2358 2359 2360 2361 /** 2362 * <p> 2363 * Returns 2364 * PD12 () - creates it if necessary 2365 * </p> 2366 * 2367 * 2368 */ 2369 public PD1 getPD12() { 2370 return getTyped("PD12", PD1.class); 2371 } 2372 2373 2374 2375 2376 2377 /** 2378 * <p> 2379 * Returns 2380 * PV12 () - creates it if necessary 2381 * </p> 2382 * 2383 * 2384 */ 2385 public PV1 getPV12() { 2386 return getTyped("PV12", PV1.class); 2387 } 2388 2389 2390 2391 2392 2393 /** 2394 * <p> 2395 * Returns 2396 * PV22 () - creates it if necessary 2397 * </p> 2398 * 2399 * 2400 */ 2401 public PV2 getPV22() { 2402 return getTyped("PV22", PV2.class); 2403 } 2404 2405 2406 2407 2408 2409 /** 2410 * <p> 2411 * Returns 2412 * the first repetition of 2413 * DB12 () - creates it if necessary 2414 * </p> 2415 * 2416 * 2417 */ 2418 public DB1 getDB12() { 2419 return getTyped("DB12", DB1.class); 2420 } 2421 2422 2423 /** 2424 * <p> 2425 * Returns a specific repetition of 2426 * DB12 () - creates it if necessary 2427 * </p> 2428 * 2429 * 2430 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2431 * @throws HL7Exception if the repetition requested is more than one 2432 * greater than the number of existing repetitions. 2433 */ 2434 public DB1 getDB12(int rep) { 2435 return getTyped("DB12", rep, DB1.class); 2436 } 2437 2438 /** 2439 * <p> 2440 * Returns the number of existing repetitions of DB12 2441 * </p> 2442 * 2443 */ 2444 public int getDB12Reps() { 2445 return getReps("DB12"); 2446 } 2447 2448 /** 2449 * <p> 2450 * Returns a non-modifiable List containing all current existing repetitions of DB12. 2451 * <p> 2452 * <p> 2453 * Note that unlike {@link #getDB12()}, this method will not create any reps 2454 * if none are already present, so an empty list may be returned. 2455 * </p> 2456 * 2457 */ 2458 public java.util.List<DB1> getDB12All() throws HL7Exception { 2459 return getAllAsList("DB12", DB1.class); 2460 } 2461 2462 /** 2463 * <p> 2464 * Inserts a specific repetition of DB12 () 2465 * </p> 2466 * 2467 * 2468 * @see AbstractGroup#insertRepetition(Structure, int) 2469 */ 2470 public void insertDB12(DB1 structure, int rep) throws HL7Exception { 2471 super.insertRepetition( "DB12", structure, rep); 2472 } 2473 2474 2475 /** 2476 * <p> 2477 * Inserts a specific repetition of DB12 () 2478 * </p> 2479 * 2480 * 2481 * @see AbstractGroup#insertRepetition(Structure, int) 2482 */ 2483 public DB1 insertDB12(int rep) throws HL7Exception { 2484 return (DB1)super.insertRepetition("DB12", rep); 2485 } 2486 2487 2488 /** 2489 * <p> 2490 * Removes a specific repetition of DB12 () 2491 * </p> 2492 * 2493 * 2494 * @see AbstractGroup#removeRepetition(String, int) 2495 */ 2496 public DB1 removeDB12(int rep) throws HL7Exception { 2497 return (DB1)super.removeRepetition("DB12", rep); 2498 } 2499 2500 2501 2502 2503 /** 2504 * <p> 2505 * Returns 2506 * the first repetition of 2507 * OBX2 () - creates it if necessary 2508 * </p> 2509 * 2510 * 2511 */ 2512 public OBX getOBX2() { 2513 return getTyped("OBX2", OBX.class); 2514 } 2515 2516 2517 /** 2518 * <p> 2519 * Returns a specific repetition of 2520 * OBX2 () - creates it if necessary 2521 * </p> 2522 * 2523 * 2524 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2525 * @throws HL7Exception if the repetition requested is more than one 2526 * greater than the number of existing repetitions. 2527 */ 2528 public OBX getOBX2(int rep) { 2529 return getTyped("OBX2", rep, OBX.class); 2530 } 2531 2532 /** 2533 * <p> 2534 * Returns the number of existing repetitions of OBX2 2535 * </p> 2536 * 2537 */ 2538 public int getOBX2Reps() { 2539 return getReps("OBX2"); 2540 } 2541 2542 /** 2543 * <p> 2544 * Returns a non-modifiable List containing all current existing repetitions of OBX2. 2545 * <p> 2546 * <p> 2547 * Note that unlike {@link #getOBX2()}, this method will not create any reps 2548 * if none are already present, so an empty list may be returned. 2549 * </p> 2550 * 2551 */ 2552 public java.util.List<OBX> getOBX2All() throws HL7Exception { 2553 return getAllAsList("OBX2", OBX.class); 2554 } 2555 2556 /** 2557 * <p> 2558 * Inserts a specific repetition of OBX2 () 2559 * </p> 2560 * 2561 * 2562 * @see AbstractGroup#insertRepetition(Structure, int) 2563 */ 2564 public void insertOBX2(OBX structure, int rep) throws HL7Exception { 2565 super.insertRepetition( "OBX2", structure, rep); 2566 } 2567 2568 2569 /** 2570 * <p> 2571 * Inserts a specific repetition of OBX2 () 2572 * </p> 2573 * 2574 * 2575 * @see AbstractGroup#insertRepetition(Structure, int) 2576 */ 2577 public OBX insertOBX2(int rep) throws HL7Exception { 2578 return (OBX)super.insertRepetition("OBX2", rep); 2579 } 2580 2581 2582 /** 2583 * <p> 2584 * Removes a specific repetition of OBX2 () 2585 * </p> 2586 * 2587 * 2588 * @see AbstractGroup#removeRepetition(String, int) 2589 */ 2590 public OBX removeOBX2(int rep) throws HL7Exception { 2591 return (OBX)super.removeRepetition("OBX2", rep); 2592 } 2593 2594 2595 2596 2597 /** 2598 * <p> 2599 * Returns 2600 * NPU () - creates it if necessary 2601 * </p> 2602 * 2603 * 2604 */ 2605 public NPU getNPU() { 2606 return getTyped("NPU", NPU.class); 2607 } 2608 2609 2610 2611 2612 2613 /** 2614 * <p> 2615 * Returns 2616 * the first repetition of 2617 * PATIENT () - creates it if necessary 2618 * </p> 2619 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2620 * 2621 */ 2622 public ADT_AXX_PATIENT getPATIENT() { 2623 return getTyped("PATIENT", ADT_AXX_PATIENT.class); 2624 } 2625 2626 2627 /** 2628 * <p> 2629 * Returns a specific repetition of 2630 * PATIENT () - creates it if necessary 2631 * </p> 2632 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2633 * 2634 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2635 * @throws HL7Exception if the repetition requested is more than one 2636 * greater than the number of existing repetitions. 2637 */ 2638 public ADT_AXX_PATIENT getPATIENT(int rep) { 2639 return getTyped("PATIENT", rep, ADT_AXX_PATIENT.class); 2640 } 2641 2642 /** 2643 * <p> 2644 * Returns the number of existing repetitions of PATIENT 2645 * </p> 2646 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2647 */ 2648 public int getPATIENTReps() { 2649 return getReps("PATIENT"); 2650 } 2651 2652 /** 2653 * <p> 2654 * Returns a non-modifiable List containing all current existing repetitions of PATIENT. 2655 * <p> 2656 * <p> 2657 * Note that unlike {@link #getPATIENT()}, this method will not create any reps 2658 * if none are already present, so an empty list may be returned. 2659 * </p> 2660 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2661 */ 2662 public java.util.List<ADT_AXX_PATIENT> getPATIENTAll() throws HL7Exception { 2663 return getAllAsList("PATIENT", ADT_AXX_PATIENT.class); 2664 } 2665 2666 /** 2667 * <p> 2668 * Inserts a specific repetition of PATIENT () 2669 * </p> 2670 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2671 * 2672 * @see AbstractGroup#insertRepetition(Structure, int) 2673 */ 2674 public void insertPATIENT(ADT_AXX_PATIENT structure, int rep) throws HL7Exception { 2675 super.insertRepetition( "PATIENT", structure, rep); 2676 } 2677 2678 2679 /** 2680 * <p> 2681 * Inserts a specific repetition of PATIENT () 2682 * </p> 2683 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2684 * 2685 * @see AbstractGroup#insertRepetition(Structure, int) 2686 */ 2687 public ADT_AXX_PATIENT insertPATIENT(int rep) throws HL7Exception { 2688 return (ADT_AXX_PATIENT)super.insertRepetition("PATIENT", rep); 2689 } 2690 2691 2692 /** 2693 * <p> 2694 * Removes a specific repetition of PATIENT () 2695 * </p> 2696 * Used for the following structures: [ADT_A42, ADT_A41, ADT_A40, ADT_A44] 2697 * 2698 * @see AbstractGroup#removeRepetition(String, int) 2699 */ 2700 public ADT_AXX_PATIENT removePATIENT(int rep) throws HL7Exception { 2701 return (ADT_AXX_PATIENT)super.removeRepetition("PATIENT", rep); 2702 } 2703 2704 2705 2706 2707 /** 2708 * <p> 2709 * Returns 2710 * the first repetition of 2711 * MERGE_INFO () - creates it if necessary 2712 * </p> 2713 * 2714 * 2715 */ 2716 public ADT_AXX_MERGE_INFO getMERGE_INFO() { 2717 return getTyped("MERGE_INFO", ADT_AXX_MERGE_INFO.class); 2718 } 2719 2720 2721 /** 2722 * <p> 2723 * Returns a specific repetition of 2724 * MERGE_INFO () - creates it if necessary 2725 * </p> 2726 * 2727 * 2728 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2729 * @throws HL7Exception if the repetition requested is more than one 2730 * greater than the number of existing repetitions. 2731 */ 2732 public ADT_AXX_MERGE_INFO getMERGE_INFO(int rep) { 2733 return getTyped("MERGE_INFO", rep, ADT_AXX_MERGE_INFO.class); 2734 } 2735 2736 /** 2737 * <p> 2738 * Returns the number of existing repetitions of MERGE_INFO 2739 * </p> 2740 * 2741 */ 2742 public int getMERGE_INFOReps() { 2743 return getReps("MERGE_INFO"); 2744 } 2745 2746 /** 2747 * <p> 2748 * Returns a non-modifiable List containing all current existing repetitions of MERGE_INFO. 2749 * <p> 2750 * <p> 2751 * Note that unlike {@link #getMERGE_INFO()}, this method will not create any reps 2752 * if none are already present, so an empty list may be returned. 2753 * </p> 2754 * 2755 */ 2756 public java.util.List<ADT_AXX_MERGE_INFO> getMERGE_INFOAll() throws HL7Exception { 2757 return getAllAsList("MERGE_INFO", ADT_AXX_MERGE_INFO.class); 2758 } 2759 2760 /** 2761 * <p> 2762 * Inserts a specific repetition of MERGE_INFO () 2763 * </p> 2764 * 2765 * 2766 * @see AbstractGroup#insertRepetition(Structure, int) 2767 */ 2768 public void insertMERGE_INFO(ADT_AXX_MERGE_INFO structure, int rep) throws HL7Exception { 2769 super.insertRepetition( "MERGE_INFO", structure, rep); 2770 } 2771 2772 2773 /** 2774 * <p> 2775 * Inserts a specific repetition of MERGE_INFO () 2776 * </p> 2777 * 2778 * 2779 * @see AbstractGroup#insertRepetition(Structure, int) 2780 */ 2781 public ADT_AXX_MERGE_INFO insertMERGE_INFO(int rep) throws HL7Exception { 2782 return (ADT_AXX_MERGE_INFO)super.insertRepetition("MERGE_INFO", rep); 2783 } 2784 2785 2786 /** 2787 * <p> 2788 * Removes a specific repetition of MERGE_INFO () 2789 * </p> 2790 * 2791 * 2792 * @see AbstractGroup#removeRepetition(String, int) 2793 */ 2794 public ADT_AXX_MERGE_INFO removeMERGE_INFO(int rep) throws HL7Exception { 2795 return (ADT_AXX_MERGE_INFO)super.removeRepetition("MERGE_INFO", rep); 2796 } 2797 2798 2799 2800 2801 /** 2802 * <p> 2803 * Returns 2804 * the first repetition of 2805 * IAM () - creates it if necessary 2806 * </p> 2807 * 2808 * 2809 */ 2810 public IAM getIAM() { 2811 return getTyped("IAM", IAM.class); 2812 } 2813 2814 2815 /** 2816 * <p> 2817 * Returns a specific repetition of 2818 * IAM () - creates it if necessary 2819 * </p> 2820 * 2821 * 2822 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 2823 * @throws HL7Exception if the repetition requested is more than one 2824 * greater than the number of existing repetitions. 2825 */ 2826 public IAM getIAM(int rep) { 2827 return getTyped("IAM", rep, IAM.class); 2828 } 2829 2830 /** 2831 * <p> 2832 * Returns the number of existing repetitions of IAM 2833 * </p> 2834 * 2835 */ 2836 public int getIAMReps() { 2837 return getReps("IAM"); 2838 } 2839 2840 /** 2841 * <p> 2842 * Returns a non-modifiable List containing all current existing repetitions of IAM. 2843 * <p> 2844 * <p> 2845 * Note that unlike {@link #getIAM()}, this method will not create any reps 2846 * if none are already present, so an empty list may be returned. 2847 * </p> 2848 * 2849 */ 2850 public java.util.List<IAM> getIAMAll() throws HL7Exception { 2851 return getAllAsList("IAM", IAM.class); 2852 } 2853 2854 /** 2855 * <p> 2856 * Inserts a specific repetition of IAM () 2857 * </p> 2858 * 2859 * 2860 * @see AbstractGroup#insertRepetition(Structure, int) 2861 */ 2862 public void insertIAM(IAM structure, int rep) throws HL7Exception { 2863 super.insertRepetition( "IAM", structure, rep); 2864 } 2865 2866 2867 /** 2868 * <p> 2869 * Inserts a specific repetition of IAM () 2870 * </p> 2871 * 2872 * 2873 * @see AbstractGroup#insertRepetition(Structure, int) 2874 */ 2875 public IAM insertIAM(int rep) throws HL7Exception { 2876 return (IAM)super.insertRepetition("IAM", rep); 2877 } 2878 2879 2880 /** 2881 * <p> 2882 * Removes a specific repetition of IAM () 2883 * </p> 2884 * 2885 * 2886 * @see AbstractGroup#removeRepetition(String, int) 2887 */ 2888 public IAM removeIAM(int rep) throws HL7Exception { 2889 return (IAM)super.removeRepetition("IAM", rep); 2890 } 2891 2892 2893 2894} 2895