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