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