001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v251.segment; 035 036// import ca.uhn.hl7v2.model.v251.group.*; 037import ca.uhn.hl7v2.model.v251.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 PID message segment (Patient Identification). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>PID-1: Set ID - PID (SI) <b>optional </b> 053 * <li>PID-2: Patient ID (CX) <b>optional </b> 054 * <li>PID-3: Patient Identifier List (CX) <b> repeating</b> 055 * <li>PID-4: Alternate Patient ID - PID (CX) <b>optional repeating</b> 056 * <li>PID-5: Patient Name (XPN) <b> repeating</b> 057 * <li>PID-6: Mother's Maiden Name (XPN) <b>optional repeating</b> 058 * <li>PID-7: Date/Time of Birth (TS) <b>optional </b> 059 * <li>PID-8: Administrative Sex (IS) <b>optional </b> 060 * <li>PID-9: Patient Alias (XPN) <b>optional repeating</b> 061 * <li>PID-10: Race (CE) <b>optional repeating</b> 062 * <li>PID-11: Patient Address (XAD) <b>optional repeating</b> 063 * <li>PID-12: County Code (IS) <b>optional </b> 064 * <li>PID-13: Phone Number - Home (XTN) <b>optional repeating</b> 065 * <li>PID-14: Phone Number - Business (XTN) <b>optional repeating</b> 066 * <li>PID-15: Primary Language (CE) <b>optional </b> 067 * <li>PID-16: Marital Status (CE) <b>optional </b> 068 * <li>PID-17: Religion (CE) <b>optional </b> 069 * <li>PID-18: Patient Account Number (CX) <b>optional </b> 070 * <li>PID-19: SSN Number - Patient (ST) <b>optional </b> 071 * <li>PID-20: Driver's License Number - Patient (DLN) <b>optional </b> 072 * <li>PID-21: Mother's Identifier (CX) <b>optional repeating</b> 073 * <li>PID-22: Ethnic Group (CE) <b>optional repeating</b> 074 * <li>PID-23: Birth Place (ST) <b>optional </b> 075 * <li>PID-24: Multiple Birth Indicator (ID) <b>optional </b> 076 * <li>PID-25: Birth Order (NM) <b>optional </b> 077 * <li>PID-26: Citizenship (CE) <b>optional repeating</b> 078 * <li>PID-27: Veterans Military Status (CE) <b>optional </b> 079 * <li>PID-28: Nationality (CE) <b>optional </b> 080 * <li>PID-29: Patient Death Date and Time (TS) <b>optional </b> 081 * <li>PID-30: Patient Death Indicator (ID) <b>optional </b> 082 * <li>PID-31: Identity Unknown Indicator (ID) <b>optional </b> 083 * <li>PID-32: Identity Reliability Code (IS) <b>optional repeating</b> 084 * <li>PID-33: Last Update Date/Time (TS) <b>optional </b> 085 * <li>PID-34: Last Update Facility (HD) <b>optional </b> 086 * <li>PID-35: Species Code (CE) <b>optional </b> 087 * <li>PID-36: Breed Code (CE) <b>optional </b> 088 * <li>PID-37: Strain (ST) <b>optional </b> 089 * <li>PID-38: Production Class Code (CE) <b>optional </b> 090 * <li>PID-39: Tribal Citizenship (CWE) <b>optional repeating</b> 091 * </ul> 092 */ 093@SuppressWarnings("unused") 094public class PID extends AbstractSegment { 095 096 /** 097 * Creates a new PID segment 098 */ 099 public PID(Group parent, ModelClassFactory factory) { 100 super(parent, factory); 101 init(factory); 102 } 103 104 private void init(ModelClassFactory factory) { 105 try { 106 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - PID"); 107 this.add(CX.class, false, 1, 20, new Object[]{ getMessage() }, "Patient ID"); 108 this.add(CX.class, true, 0, 250, new Object[]{ getMessage() }, "Patient Identifier List"); 109 this.add(CX.class, false, 0, 20, new Object[]{ getMessage() }, "Alternate Patient ID - PID"); 110 this.add(XPN.class, true, 0, 250, new Object[]{ getMessage() }, "Patient Name"); 111 this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Mother's Maiden Name"); 112 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of Birth"); 113 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Administrative Sex"); 114 this.add(XPN.class, false, 0, 250, new Object[]{ getMessage() }, "Patient Alias"); 115 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Race"); 116 this.add(XAD.class, false, 0, 250, new Object[]{ getMessage() }, "Patient Address"); 117 this.add(IS.class, false, 1, 4, new Object[]{ getMessage(), new Integer(289) }, "County Code"); 118 this.add(XTN.class, false, 0, 250, new Object[]{ getMessage() }, "Phone Number - Home"); 119 this.add(XTN.class, false, 0, 250, new Object[]{ getMessage() }, "Phone Number - Business"); 120 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Primary Language"); 121 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Marital Status"); 122 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Religion"); 123 this.add(CX.class, false, 1, 250, new Object[]{ getMessage() }, "Patient Account Number"); 124 this.add(ST.class, false, 1, 16, new Object[]{ getMessage() }, "SSN Number - Patient"); 125 this.add(DLN.class, false, 1, 25, new Object[]{ getMessage() }, "Driver's License Number - Patient"); 126 this.add(CX.class, false, 0, 250, new Object[]{ getMessage() }, "Mother's Identifier"); 127 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Ethnic Group"); 128 this.add(ST.class, false, 1, 250, new Object[]{ getMessage() }, "Birth Place"); 129 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Multiple Birth Indicator"); 130 this.add(NM.class, false, 1, 2, new Object[]{ getMessage() }, "Birth Order"); 131 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Citizenship"); 132 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Veterans Military Status"); 133 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Nationality"); 134 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Patient Death Date and Time"); 135 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Patient Death Indicator"); 136 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Identity Unknown Indicator"); 137 this.add(IS.class, false, 0, 20, new Object[]{ getMessage(), new Integer(445) }, "Identity Reliability Code"); 138 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Last Update Date/Time"); 139 this.add(HD.class, false, 1, 241, new Object[]{ getMessage() }, "Last Update Facility"); 140 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Species Code"); 141 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Breed Code"); 142 this.add(ST.class, false, 1, 80, new Object[]{ getMessage() }, "Strain"); 143 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Production Class Code"); 144 this.add(CWE.class, false, 0, 250, new Object[]{ getMessage() }, "Tribal Citizenship"); 145 } catch(HL7Exception e) { 146 log.error("Unexpected error creating PID - this is probably a bug in the source code generator.", e); 147 } 148 } 149 150 151 152 /** 153 * Returns 154 * PID-1: "Set ID - PID" - creates it if necessary 155 */ 156 public SI getSetIDPID() { 157 SI retVal = this.getTypedField(1, 0); 158 return retVal; 159 } 160 161 /** 162 * Returns 163 * PID-1: "Set ID - PID" - creates it if necessary 164 */ 165 public SI getPid1_SetIDPID() { 166 SI retVal = this.getTypedField(1, 0); 167 return retVal; 168 } 169 170 171 172 /** 173 * Returns 174 * PID-2: "Patient ID" - creates it if necessary 175 */ 176 public CX getPatientID() { 177 CX retVal = this.getTypedField(2, 0); 178 return retVal; 179 } 180 181 /** 182 * Returns 183 * PID-2: "Patient ID" - creates it if necessary 184 */ 185 public CX getPid2_PatientID() { 186 CX retVal = this.getTypedField(2, 0); 187 return retVal; 188 } 189 190 191 /** 192 * Returns all repetitions of Patient Identifier List (PID-3). 193 */ 194 public CX[] getPatientIdentifierList() { 195 CX[] retVal = this.getTypedField(3, new CX[0]); 196 return retVal; 197 } 198 199 200 /** 201 * Returns all repetitions of Patient Identifier List (PID-3). 202 */ 203 public CX[] getPid3_PatientIdentifierList() { 204 CX[] retVal = this.getTypedField(3, new CX[0]); 205 return retVal; 206 } 207 208 209 /** 210 * Returns a count of the current number of repetitions of Patient Identifier List (PID-3). 211 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 212 * it will return zero. 213 */ 214 public int getPatientIdentifierListReps() { 215 return this.getReps(3); 216 } 217 218 219 /** 220 * Returns a specific repetition of 221 * PID-3: "Patient Identifier List" - creates it if necessary 222 * 223 * @param rep The repetition index (0-indexed) 224 */ 225 public CX getPatientIdentifierList(int rep) { 226 CX retVal = this.getTypedField(3, rep); 227 return retVal; 228 } 229 230 /** 231 * Returns a specific repetition of 232 * PID-3: "Patient Identifier List" - creates it if necessary 233 * 234 * @param rep The repetition index (0-indexed) 235 */ 236 public CX getPid3_PatientIdentifierList(int rep) { 237 CX retVal = this.getTypedField(3, rep); 238 return retVal; 239 } 240 241 /** 242 * Returns a count of the current number of repetitions of Patient Identifier List (PID-3). 243 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 244 * it will return zero. 245 */ 246 public int getPid3_PatientIdentifierListReps() { 247 return this.getReps(3); 248 } 249 250 251 /** 252 * Inserts a repetition of 253 * PID-3: "Patient Identifier List" at a specific index 254 * 255 * @param rep The repetition index (0-indexed) 256 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 257 */ 258 public CX insertPatientIdentifierList(int rep) throws HL7Exception { 259 return (CX) super.insertRepetition(3, rep); 260 } 261 262 263 /** 264 * Inserts a repetition of 265 * PID-3: "Patient Identifier List" at a specific index 266 * 267 * @param rep The repetition index (0-indexed) 268 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 269 */ 270 public CX insertPid3_PatientIdentifierList(int rep) throws HL7Exception { 271 return (CX) super.insertRepetition(3, rep); 272 } 273 274 275 /** 276 * Removes a repetition of 277 * PID-3: "Patient Identifier List" at a specific index 278 * 279 * @param rep The repetition index (0-indexed) 280 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 281 */ 282 public CX removePatientIdentifierList(int rep) throws HL7Exception { 283 return (CX) super.removeRepetition(3, rep); 284 } 285 286 287 /** 288 * Removes a repetition of 289 * PID-3: "Patient Identifier List" at a specific index 290 * 291 * @param rep The repetition index (0-indexed) 292 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 293 */ 294 public CX removePid3_PatientIdentifierList(int rep) throws HL7Exception { 295 return (CX) super.removeRepetition(3, rep); 296 } 297 298 299 300 /** 301 * Returns all repetitions of Alternate Patient ID - PID (PID-4). 302 */ 303 public CX[] getAlternatePatientIDPID() { 304 CX[] retVal = this.getTypedField(4, new CX[0]); 305 return retVal; 306 } 307 308 309 /** 310 * Returns all repetitions of Alternate Patient ID - PID (PID-4). 311 */ 312 public CX[] getPid4_AlternatePatientIDPID() { 313 CX[] retVal = this.getTypedField(4, new CX[0]); 314 return retVal; 315 } 316 317 318 /** 319 * Returns a count of the current number of repetitions of Alternate Patient ID - PID (PID-4). 320 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 321 * it will return zero. 322 */ 323 public int getAlternatePatientIDPIDReps() { 324 return this.getReps(4); 325 } 326 327 328 /** 329 * Returns a specific repetition of 330 * PID-4: "Alternate Patient ID - PID" - creates it if necessary 331 * 332 * @param rep The repetition index (0-indexed) 333 */ 334 public CX getAlternatePatientIDPID(int rep) { 335 CX retVal = this.getTypedField(4, rep); 336 return retVal; 337 } 338 339 /** 340 * Returns a specific repetition of 341 * PID-4: "Alternate Patient ID - PID" - creates it if necessary 342 * 343 * @param rep The repetition index (0-indexed) 344 */ 345 public CX getPid4_AlternatePatientIDPID(int rep) { 346 CX retVal = this.getTypedField(4, rep); 347 return retVal; 348 } 349 350 /** 351 * Returns a count of the current number of repetitions of Alternate Patient ID - PID (PID-4). 352 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 353 * it will return zero. 354 */ 355 public int getPid4_AlternatePatientIDPIDReps() { 356 return this.getReps(4); 357 } 358 359 360 /** 361 * Inserts a repetition of 362 * PID-4: "Alternate Patient ID - PID" at a specific index 363 * 364 * @param rep The repetition index (0-indexed) 365 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 366 */ 367 public CX insertAlternatePatientIDPID(int rep) throws HL7Exception { 368 return (CX) super.insertRepetition(4, rep); 369 } 370 371 372 /** 373 * Inserts a repetition of 374 * PID-4: "Alternate Patient ID - PID" at a specific index 375 * 376 * @param rep The repetition index (0-indexed) 377 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 378 */ 379 public CX insertPid4_AlternatePatientIDPID(int rep) throws HL7Exception { 380 return (CX) super.insertRepetition(4, rep); 381 } 382 383 384 /** 385 * Removes a repetition of 386 * PID-4: "Alternate Patient ID - PID" at a specific index 387 * 388 * @param rep The repetition index (0-indexed) 389 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 390 */ 391 public CX removeAlternatePatientIDPID(int rep) throws HL7Exception { 392 return (CX) super.removeRepetition(4, rep); 393 } 394 395 396 /** 397 * Removes a repetition of 398 * PID-4: "Alternate Patient ID - PID" at a specific index 399 * 400 * @param rep The repetition index (0-indexed) 401 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 402 */ 403 public CX removePid4_AlternatePatientIDPID(int rep) throws HL7Exception { 404 return (CX) super.removeRepetition(4, rep); 405 } 406 407 408 409 /** 410 * Returns all repetitions of Patient Name (PID-5). 411 */ 412 public XPN[] getPatientName() { 413 XPN[] retVal = this.getTypedField(5, new XPN[0]); 414 return retVal; 415 } 416 417 418 /** 419 * Returns all repetitions of Patient Name (PID-5). 420 */ 421 public XPN[] getPid5_PatientName() { 422 XPN[] retVal = this.getTypedField(5, new XPN[0]); 423 return retVal; 424 } 425 426 427 /** 428 * Returns a count of the current number of repetitions of Patient Name (PID-5). 429 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 430 * it will return zero. 431 */ 432 public int getPatientNameReps() { 433 return this.getReps(5); 434 } 435 436 437 /** 438 * Returns a specific repetition of 439 * PID-5: "Patient Name" - creates it if necessary 440 * 441 * @param rep The repetition index (0-indexed) 442 */ 443 public XPN getPatientName(int rep) { 444 XPN retVal = this.getTypedField(5, rep); 445 return retVal; 446 } 447 448 /** 449 * Returns a specific repetition of 450 * PID-5: "Patient Name" - creates it if necessary 451 * 452 * @param rep The repetition index (0-indexed) 453 */ 454 public XPN getPid5_PatientName(int rep) { 455 XPN retVal = this.getTypedField(5, rep); 456 return retVal; 457 } 458 459 /** 460 * Returns a count of the current number of repetitions of Patient Name (PID-5). 461 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 462 * it will return zero. 463 */ 464 public int getPid5_PatientNameReps() { 465 return this.getReps(5); 466 } 467 468 469 /** 470 * Inserts a repetition of 471 * PID-5: "Patient Name" at a specific index 472 * 473 * @param rep The repetition index (0-indexed) 474 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 475 */ 476 public XPN insertPatientName(int rep) throws HL7Exception { 477 return (XPN) super.insertRepetition(5, rep); 478 } 479 480 481 /** 482 * Inserts a repetition of 483 * PID-5: "Patient Name" at a specific index 484 * 485 * @param rep The repetition index (0-indexed) 486 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 487 */ 488 public XPN insertPid5_PatientName(int rep) throws HL7Exception { 489 return (XPN) super.insertRepetition(5, rep); 490 } 491 492 493 /** 494 * Removes a repetition of 495 * PID-5: "Patient Name" at a specific index 496 * 497 * @param rep The repetition index (0-indexed) 498 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 499 */ 500 public XPN removePatientName(int rep) throws HL7Exception { 501 return (XPN) super.removeRepetition(5, rep); 502 } 503 504 505 /** 506 * Removes a repetition of 507 * PID-5: "Patient Name" at a specific index 508 * 509 * @param rep The repetition index (0-indexed) 510 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 511 */ 512 public XPN removePid5_PatientName(int rep) throws HL7Exception { 513 return (XPN) super.removeRepetition(5, rep); 514 } 515 516 517 518 /** 519 * Returns all repetitions of Mother's Maiden Name (PID-6). 520 */ 521 public XPN[] getMotherSMaidenName() { 522 XPN[] retVal = this.getTypedField(6, new XPN[0]); 523 return retVal; 524 } 525 526 527 /** 528 * Returns all repetitions of Mother's Maiden Name (PID-6). 529 */ 530 public XPN[] getPid6_MotherSMaidenName() { 531 XPN[] retVal = this.getTypedField(6, new XPN[0]); 532 return retVal; 533 } 534 535 536 /** 537 * Returns a count of the current number of repetitions of Mother's Maiden Name (PID-6). 538 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 539 * it will return zero. 540 */ 541 public int getMotherSMaidenNameReps() { 542 return this.getReps(6); 543 } 544 545 546 /** 547 * Returns a specific repetition of 548 * PID-6: "Mother's Maiden Name" - creates it if necessary 549 * 550 * @param rep The repetition index (0-indexed) 551 */ 552 public XPN getMotherSMaidenName(int rep) { 553 XPN retVal = this.getTypedField(6, rep); 554 return retVal; 555 } 556 557 /** 558 * Returns a specific repetition of 559 * PID-6: "Mother's Maiden Name" - creates it if necessary 560 * 561 * @param rep The repetition index (0-indexed) 562 */ 563 public XPN getPid6_MotherSMaidenName(int rep) { 564 XPN retVal = this.getTypedField(6, rep); 565 return retVal; 566 } 567 568 /** 569 * Returns a count of the current number of repetitions of Mother's Maiden Name (PID-6). 570 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 571 * it will return zero. 572 */ 573 public int getPid6_MotherSMaidenNameReps() { 574 return this.getReps(6); 575 } 576 577 578 /** 579 * Inserts a repetition of 580 * PID-6: "Mother's Maiden Name" at a specific index 581 * 582 * @param rep The repetition index (0-indexed) 583 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 584 */ 585 public XPN insertMotherSMaidenName(int rep) throws HL7Exception { 586 return (XPN) super.insertRepetition(6, rep); 587 } 588 589 590 /** 591 * Inserts a repetition of 592 * PID-6: "Mother's Maiden Name" at a specific index 593 * 594 * @param rep The repetition index (0-indexed) 595 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 596 */ 597 public XPN insertPid6_MotherSMaidenName(int rep) throws HL7Exception { 598 return (XPN) super.insertRepetition(6, rep); 599 } 600 601 602 /** 603 * Removes a repetition of 604 * PID-6: "Mother's Maiden Name" at a specific index 605 * 606 * @param rep The repetition index (0-indexed) 607 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 608 */ 609 public XPN removeMotherSMaidenName(int rep) throws HL7Exception { 610 return (XPN) super.removeRepetition(6, rep); 611 } 612 613 614 /** 615 * Removes a repetition of 616 * PID-6: "Mother's Maiden Name" at a specific index 617 * 618 * @param rep The repetition index (0-indexed) 619 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 620 */ 621 public XPN removePid6_MotherSMaidenName(int rep) throws HL7Exception { 622 return (XPN) super.removeRepetition(6, rep); 623 } 624 625 626 627 628 /** 629 * Returns 630 * PID-7: "Date/Time of Birth" - creates it if necessary 631 */ 632 public TS getDateTimeOfBirth() { 633 TS retVal = this.getTypedField(7, 0); 634 return retVal; 635 } 636 637 /** 638 * Returns 639 * PID-7: "Date/Time of Birth" - creates it if necessary 640 */ 641 public TS getPid7_DateTimeOfBirth() { 642 TS retVal = this.getTypedField(7, 0); 643 return retVal; 644 } 645 646 647 648 /** 649 * Returns 650 * PID-8: "Administrative Sex" - creates it if necessary 651 */ 652 public IS getAdministrativeSex() { 653 IS retVal = this.getTypedField(8, 0); 654 return retVal; 655 } 656 657 /** 658 * Returns 659 * PID-8: "Administrative Sex" - creates it if necessary 660 */ 661 public IS getPid8_AdministrativeSex() { 662 IS retVal = this.getTypedField(8, 0); 663 return retVal; 664 } 665 666 667 /** 668 * Returns all repetitions of Patient Alias (PID-9). 669 */ 670 public XPN[] getPatientAlias() { 671 XPN[] retVal = this.getTypedField(9, new XPN[0]); 672 return retVal; 673 } 674 675 676 /** 677 * Returns all repetitions of Patient Alias (PID-9). 678 */ 679 public XPN[] getPid9_PatientAlias() { 680 XPN[] retVal = this.getTypedField(9, new XPN[0]); 681 return retVal; 682 } 683 684 685 /** 686 * Returns a count of the current number of repetitions of Patient Alias (PID-9). 687 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 688 * it will return zero. 689 */ 690 public int getPatientAliasReps() { 691 return this.getReps(9); 692 } 693 694 695 /** 696 * Returns a specific repetition of 697 * PID-9: "Patient Alias" - creates it if necessary 698 * 699 * @param rep The repetition index (0-indexed) 700 */ 701 public XPN getPatientAlias(int rep) { 702 XPN retVal = this.getTypedField(9, rep); 703 return retVal; 704 } 705 706 /** 707 * Returns a specific repetition of 708 * PID-9: "Patient Alias" - creates it if necessary 709 * 710 * @param rep The repetition index (0-indexed) 711 */ 712 public XPN getPid9_PatientAlias(int rep) { 713 XPN retVal = this.getTypedField(9, rep); 714 return retVal; 715 } 716 717 /** 718 * Returns a count of the current number of repetitions of Patient Alias (PID-9). 719 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 720 * it will return zero. 721 */ 722 public int getPid9_PatientAliasReps() { 723 return this.getReps(9); 724 } 725 726 727 /** 728 * Inserts a repetition of 729 * PID-9: "Patient Alias" at a specific index 730 * 731 * @param rep The repetition index (0-indexed) 732 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 733 */ 734 public XPN insertPatientAlias(int rep) throws HL7Exception { 735 return (XPN) super.insertRepetition(9, rep); 736 } 737 738 739 /** 740 * Inserts a repetition of 741 * PID-9: "Patient Alias" at a specific index 742 * 743 * @param rep The repetition index (0-indexed) 744 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 745 */ 746 public XPN insertPid9_PatientAlias(int rep) throws HL7Exception { 747 return (XPN) super.insertRepetition(9, rep); 748 } 749 750 751 /** 752 * Removes a repetition of 753 * PID-9: "Patient Alias" at a specific index 754 * 755 * @param rep The repetition index (0-indexed) 756 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 757 */ 758 public XPN removePatientAlias(int rep) throws HL7Exception { 759 return (XPN) super.removeRepetition(9, rep); 760 } 761 762 763 /** 764 * Removes a repetition of 765 * PID-9: "Patient Alias" at a specific index 766 * 767 * @param rep The repetition index (0-indexed) 768 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 769 */ 770 public XPN removePid9_PatientAlias(int rep) throws HL7Exception { 771 return (XPN) super.removeRepetition(9, rep); 772 } 773 774 775 776 /** 777 * Returns all repetitions of Race (PID-10). 778 */ 779 public CE[] getRace() { 780 CE[] retVal = this.getTypedField(10, new CE[0]); 781 return retVal; 782 } 783 784 785 /** 786 * Returns all repetitions of Race (PID-10). 787 */ 788 public CE[] getPid10_Race() { 789 CE[] retVal = this.getTypedField(10, new CE[0]); 790 return retVal; 791 } 792 793 794 /** 795 * Returns a count of the current number of repetitions of Race (PID-10). 796 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 797 * it will return zero. 798 */ 799 public int getRaceReps() { 800 return this.getReps(10); 801 } 802 803 804 /** 805 * Returns a specific repetition of 806 * PID-10: "Race" - creates it if necessary 807 * 808 * @param rep The repetition index (0-indexed) 809 */ 810 public CE getRace(int rep) { 811 CE retVal = this.getTypedField(10, rep); 812 return retVal; 813 } 814 815 /** 816 * Returns a specific repetition of 817 * PID-10: "Race" - creates it if necessary 818 * 819 * @param rep The repetition index (0-indexed) 820 */ 821 public CE getPid10_Race(int rep) { 822 CE retVal = this.getTypedField(10, rep); 823 return retVal; 824 } 825 826 /** 827 * Returns a count of the current number of repetitions of Race (PID-10). 828 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 829 * it will return zero. 830 */ 831 public int getPid10_RaceReps() { 832 return this.getReps(10); 833 } 834 835 836 /** 837 * Inserts a repetition of 838 * PID-10: "Race" at a specific index 839 * 840 * @param rep The repetition index (0-indexed) 841 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 842 */ 843 public CE insertRace(int rep) throws HL7Exception { 844 return (CE) super.insertRepetition(10, rep); 845 } 846 847 848 /** 849 * Inserts a repetition of 850 * PID-10: "Race" at a specific index 851 * 852 * @param rep The repetition index (0-indexed) 853 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 854 */ 855 public CE insertPid10_Race(int rep) throws HL7Exception { 856 return (CE) super.insertRepetition(10, rep); 857 } 858 859 860 /** 861 * Removes a repetition of 862 * PID-10: "Race" at a specific index 863 * 864 * @param rep The repetition index (0-indexed) 865 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 866 */ 867 public CE removeRace(int rep) throws HL7Exception { 868 return (CE) super.removeRepetition(10, rep); 869 } 870 871 872 /** 873 * Removes a repetition of 874 * PID-10: "Race" at a specific index 875 * 876 * @param rep The repetition index (0-indexed) 877 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 878 */ 879 public CE removePid10_Race(int rep) throws HL7Exception { 880 return (CE) super.removeRepetition(10, rep); 881 } 882 883 884 885 /** 886 * Returns all repetitions of Patient Address (PID-11). 887 */ 888 public XAD[] getPatientAddress() { 889 XAD[] retVal = this.getTypedField(11, new XAD[0]); 890 return retVal; 891 } 892 893 894 /** 895 * Returns all repetitions of Patient Address (PID-11). 896 */ 897 public XAD[] getPid11_PatientAddress() { 898 XAD[] retVal = this.getTypedField(11, new XAD[0]); 899 return retVal; 900 } 901 902 903 /** 904 * Returns a count of the current number of repetitions of Patient Address (PID-11). 905 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 906 * it will return zero. 907 */ 908 public int getPatientAddressReps() { 909 return this.getReps(11); 910 } 911 912 913 /** 914 * Returns a specific repetition of 915 * PID-11: "Patient Address" - creates it if necessary 916 * 917 * @param rep The repetition index (0-indexed) 918 */ 919 public XAD getPatientAddress(int rep) { 920 XAD retVal = this.getTypedField(11, rep); 921 return retVal; 922 } 923 924 /** 925 * Returns a specific repetition of 926 * PID-11: "Patient Address" - creates it if necessary 927 * 928 * @param rep The repetition index (0-indexed) 929 */ 930 public XAD getPid11_PatientAddress(int rep) { 931 XAD retVal = this.getTypedField(11, rep); 932 return retVal; 933 } 934 935 /** 936 * Returns a count of the current number of repetitions of Patient Address (PID-11). 937 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 938 * it will return zero. 939 */ 940 public int getPid11_PatientAddressReps() { 941 return this.getReps(11); 942 } 943 944 945 /** 946 * Inserts a repetition of 947 * PID-11: "Patient Address" at a specific index 948 * 949 * @param rep The repetition index (0-indexed) 950 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 951 */ 952 public XAD insertPatientAddress(int rep) throws HL7Exception { 953 return (XAD) super.insertRepetition(11, rep); 954 } 955 956 957 /** 958 * Inserts a repetition of 959 * PID-11: "Patient Address" at a specific index 960 * 961 * @param rep The repetition index (0-indexed) 962 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 963 */ 964 public XAD insertPid11_PatientAddress(int rep) throws HL7Exception { 965 return (XAD) super.insertRepetition(11, rep); 966 } 967 968 969 /** 970 * Removes a repetition of 971 * PID-11: "Patient Address" at a specific index 972 * 973 * @param rep The repetition index (0-indexed) 974 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 975 */ 976 public XAD removePatientAddress(int rep) throws HL7Exception { 977 return (XAD) super.removeRepetition(11, rep); 978 } 979 980 981 /** 982 * Removes a repetition of 983 * PID-11: "Patient Address" at a specific index 984 * 985 * @param rep The repetition index (0-indexed) 986 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 987 */ 988 public XAD removePid11_PatientAddress(int rep) throws HL7Exception { 989 return (XAD) super.removeRepetition(11, rep); 990 } 991 992 993 994 995 /** 996 * Returns 997 * PID-12: "County Code" - creates it if necessary 998 */ 999 public IS getCountyCode() { 1000 IS retVal = this.getTypedField(12, 0); 1001 return retVal; 1002 } 1003 1004 /** 1005 * Returns 1006 * PID-12: "County Code" - creates it if necessary 1007 */ 1008 public IS getPid12_CountyCode() { 1009 IS retVal = this.getTypedField(12, 0); 1010 return retVal; 1011 } 1012 1013 1014 /** 1015 * Returns all repetitions of Phone Number - Home (PID-13). 1016 */ 1017 public XTN[] getPhoneNumberHome() { 1018 XTN[] retVal = this.getTypedField(13, new XTN[0]); 1019 return retVal; 1020 } 1021 1022 1023 /** 1024 * Returns all repetitions of Phone Number - Home (PID-13). 1025 */ 1026 public XTN[] getPid13_PhoneNumberHome() { 1027 XTN[] retVal = this.getTypedField(13, new XTN[0]); 1028 return retVal; 1029 } 1030 1031 1032 /** 1033 * Returns a count of the current number of repetitions of Phone Number - Home (PID-13). 1034 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1035 * it will return zero. 1036 */ 1037 public int getPhoneNumberHomeReps() { 1038 return this.getReps(13); 1039 } 1040 1041 1042 /** 1043 * Returns a specific repetition of 1044 * PID-13: "Phone Number - Home" - creates it if necessary 1045 * 1046 * @param rep The repetition index (0-indexed) 1047 */ 1048 public XTN getPhoneNumberHome(int rep) { 1049 XTN retVal = this.getTypedField(13, rep); 1050 return retVal; 1051 } 1052 1053 /** 1054 * Returns a specific repetition of 1055 * PID-13: "Phone Number - Home" - creates it if necessary 1056 * 1057 * @param rep The repetition index (0-indexed) 1058 */ 1059 public XTN getPid13_PhoneNumberHome(int rep) { 1060 XTN retVal = this.getTypedField(13, rep); 1061 return retVal; 1062 } 1063 1064 /** 1065 * Returns a count of the current number of repetitions of Phone Number - Home (PID-13). 1066 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1067 * it will return zero. 1068 */ 1069 public int getPid13_PhoneNumberHomeReps() { 1070 return this.getReps(13); 1071 } 1072 1073 1074 /** 1075 * Inserts a repetition of 1076 * PID-13: "Phone Number - Home" at a specific index 1077 * 1078 * @param rep The repetition index (0-indexed) 1079 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1080 */ 1081 public XTN insertPhoneNumberHome(int rep) throws HL7Exception { 1082 return (XTN) super.insertRepetition(13, rep); 1083 } 1084 1085 1086 /** 1087 * Inserts a repetition of 1088 * PID-13: "Phone Number - Home" at a specific index 1089 * 1090 * @param rep The repetition index (0-indexed) 1091 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1092 */ 1093 public XTN insertPid13_PhoneNumberHome(int rep) throws HL7Exception { 1094 return (XTN) super.insertRepetition(13, rep); 1095 } 1096 1097 1098 /** 1099 * Removes a repetition of 1100 * PID-13: "Phone Number - Home" at a specific index 1101 * 1102 * @param rep The repetition index (0-indexed) 1103 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1104 */ 1105 public XTN removePhoneNumberHome(int rep) throws HL7Exception { 1106 return (XTN) super.removeRepetition(13, rep); 1107 } 1108 1109 1110 /** 1111 * Removes a repetition of 1112 * PID-13: "Phone Number - Home" at a specific index 1113 * 1114 * @param rep The repetition index (0-indexed) 1115 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1116 */ 1117 public XTN removePid13_PhoneNumberHome(int rep) throws HL7Exception { 1118 return (XTN) super.removeRepetition(13, rep); 1119 } 1120 1121 1122 1123 /** 1124 * Returns all repetitions of Phone Number - Business (PID-14). 1125 */ 1126 public XTN[] getPhoneNumberBusiness() { 1127 XTN[] retVal = this.getTypedField(14, new XTN[0]); 1128 return retVal; 1129 } 1130 1131 1132 /** 1133 * Returns all repetitions of Phone Number - Business (PID-14). 1134 */ 1135 public XTN[] getPid14_PhoneNumberBusiness() { 1136 XTN[] retVal = this.getTypedField(14, new XTN[0]); 1137 return retVal; 1138 } 1139 1140 1141 /** 1142 * Returns a count of the current number of repetitions of Phone Number - Business (PID-14). 1143 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1144 * it will return zero. 1145 */ 1146 public int getPhoneNumberBusinessReps() { 1147 return this.getReps(14); 1148 } 1149 1150 1151 /** 1152 * Returns a specific repetition of 1153 * PID-14: "Phone Number - Business" - creates it if necessary 1154 * 1155 * @param rep The repetition index (0-indexed) 1156 */ 1157 public XTN getPhoneNumberBusiness(int rep) { 1158 XTN retVal = this.getTypedField(14, rep); 1159 return retVal; 1160 } 1161 1162 /** 1163 * Returns a specific repetition of 1164 * PID-14: "Phone Number - Business" - creates it if necessary 1165 * 1166 * @param rep The repetition index (0-indexed) 1167 */ 1168 public XTN getPid14_PhoneNumberBusiness(int rep) { 1169 XTN retVal = this.getTypedField(14, rep); 1170 return retVal; 1171 } 1172 1173 /** 1174 * Returns a count of the current number of repetitions of Phone Number - Business (PID-14). 1175 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1176 * it will return zero. 1177 */ 1178 public int getPid14_PhoneNumberBusinessReps() { 1179 return this.getReps(14); 1180 } 1181 1182 1183 /** 1184 * Inserts a repetition of 1185 * PID-14: "Phone Number - Business" at a specific index 1186 * 1187 * @param rep The repetition index (0-indexed) 1188 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1189 */ 1190 public XTN insertPhoneNumberBusiness(int rep) throws HL7Exception { 1191 return (XTN) super.insertRepetition(14, rep); 1192 } 1193 1194 1195 /** 1196 * Inserts a repetition of 1197 * PID-14: "Phone Number - Business" at a specific index 1198 * 1199 * @param rep The repetition index (0-indexed) 1200 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1201 */ 1202 public XTN insertPid14_PhoneNumberBusiness(int rep) throws HL7Exception { 1203 return (XTN) super.insertRepetition(14, rep); 1204 } 1205 1206 1207 /** 1208 * Removes a repetition of 1209 * PID-14: "Phone Number - Business" at a specific index 1210 * 1211 * @param rep The repetition index (0-indexed) 1212 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1213 */ 1214 public XTN removePhoneNumberBusiness(int rep) throws HL7Exception { 1215 return (XTN) super.removeRepetition(14, rep); 1216 } 1217 1218 1219 /** 1220 * Removes a repetition of 1221 * PID-14: "Phone Number - Business" at a specific index 1222 * 1223 * @param rep The repetition index (0-indexed) 1224 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1225 */ 1226 public XTN removePid14_PhoneNumberBusiness(int rep) throws HL7Exception { 1227 return (XTN) super.removeRepetition(14, rep); 1228 } 1229 1230 1231 1232 1233 /** 1234 * Returns 1235 * PID-15: "Primary Language" - creates it if necessary 1236 */ 1237 public CE getPrimaryLanguage() { 1238 CE retVal = this.getTypedField(15, 0); 1239 return retVal; 1240 } 1241 1242 /** 1243 * Returns 1244 * PID-15: "Primary Language" - creates it if necessary 1245 */ 1246 public CE getPid15_PrimaryLanguage() { 1247 CE retVal = this.getTypedField(15, 0); 1248 return retVal; 1249 } 1250 1251 1252 1253 /** 1254 * Returns 1255 * PID-16: "Marital Status" - creates it if necessary 1256 */ 1257 public CE getMaritalStatus() { 1258 CE retVal = this.getTypedField(16, 0); 1259 return retVal; 1260 } 1261 1262 /** 1263 * Returns 1264 * PID-16: "Marital Status" - creates it if necessary 1265 */ 1266 public CE getPid16_MaritalStatus() { 1267 CE retVal = this.getTypedField(16, 0); 1268 return retVal; 1269 } 1270 1271 1272 1273 /** 1274 * Returns 1275 * PID-17: "Religion" - creates it if necessary 1276 */ 1277 public CE getReligion() { 1278 CE retVal = this.getTypedField(17, 0); 1279 return retVal; 1280 } 1281 1282 /** 1283 * Returns 1284 * PID-17: "Religion" - creates it if necessary 1285 */ 1286 public CE getPid17_Religion() { 1287 CE retVal = this.getTypedField(17, 0); 1288 return retVal; 1289 } 1290 1291 1292 1293 /** 1294 * Returns 1295 * PID-18: "Patient Account Number" - creates it if necessary 1296 */ 1297 public CX getPatientAccountNumber() { 1298 CX retVal = this.getTypedField(18, 0); 1299 return retVal; 1300 } 1301 1302 /** 1303 * Returns 1304 * PID-18: "Patient Account Number" - creates it if necessary 1305 */ 1306 public CX getPid18_PatientAccountNumber() { 1307 CX retVal = this.getTypedField(18, 0); 1308 return retVal; 1309 } 1310 1311 1312 1313 /** 1314 * Returns 1315 * PID-19: "SSN Number - Patient" - creates it if necessary 1316 */ 1317 public ST getSSNNumberPatient() { 1318 ST retVal = this.getTypedField(19, 0); 1319 return retVal; 1320 } 1321 1322 /** 1323 * Returns 1324 * PID-19: "SSN Number - Patient" - creates it if necessary 1325 */ 1326 public ST getPid19_SSNNumberPatient() { 1327 ST retVal = this.getTypedField(19, 0); 1328 return retVal; 1329 } 1330 1331 1332 1333 /** 1334 * Returns 1335 * PID-20: "Driver's License Number - Patient" - creates it if necessary 1336 */ 1337 public DLN getDriverSLicenseNumberPatient() { 1338 DLN retVal = this.getTypedField(20, 0); 1339 return retVal; 1340 } 1341 1342 /** 1343 * Returns 1344 * PID-20: "Driver's License Number - Patient" - creates it if necessary 1345 */ 1346 public DLN getPid20_DriverSLicenseNumberPatient() { 1347 DLN retVal = this.getTypedField(20, 0); 1348 return retVal; 1349 } 1350 1351 1352 /** 1353 * Returns all repetitions of Mother's Identifier (PID-21). 1354 */ 1355 public CX[] getMotherSIdentifier() { 1356 CX[] retVal = this.getTypedField(21, new CX[0]); 1357 return retVal; 1358 } 1359 1360 1361 /** 1362 * Returns all repetitions of Mother's Identifier (PID-21). 1363 */ 1364 public CX[] getPid21_MotherSIdentifier() { 1365 CX[] retVal = this.getTypedField(21, new CX[0]); 1366 return retVal; 1367 } 1368 1369 1370 /** 1371 * Returns a count of the current number of repetitions of Mother's Identifier (PID-21). 1372 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1373 * it will return zero. 1374 */ 1375 public int getMotherSIdentifierReps() { 1376 return this.getReps(21); 1377 } 1378 1379 1380 /** 1381 * Returns a specific repetition of 1382 * PID-21: "Mother's Identifier" - creates it if necessary 1383 * 1384 * @param rep The repetition index (0-indexed) 1385 */ 1386 public CX getMotherSIdentifier(int rep) { 1387 CX retVal = this.getTypedField(21, rep); 1388 return retVal; 1389 } 1390 1391 /** 1392 * Returns a specific repetition of 1393 * PID-21: "Mother's Identifier" - creates it if necessary 1394 * 1395 * @param rep The repetition index (0-indexed) 1396 */ 1397 public CX getPid21_MotherSIdentifier(int rep) { 1398 CX retVal = this.getTypedField(21, rep); 1399 return retVal; 1400 } 1401 1402 /** 1403 * Returns a count of the current number of repetitions of Mother's Identifier (PID-21). 1404 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1405 * it will return zero. 1406 */ 1407 public int getPid21_MotherSIdentifierReps() { 1408 return this.getReps(21); 1409 } 1410 1411 1412 /** 1413 * Inserts a repetition of 1414 * PID-21: "Mother's Identifier" at a specific index 1415 * 1416 * @param rep The repetition index (0-indexed) 1417 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1418 */ 1419 public CX insertMotherSIdentifier(int rep) throws HL7Exception { 1420 return (CX) super.insertRepetition(21, rep); 1421 } 1422 1423 1424 /** 1425 * Inserts a repetition of 1426 * PID-21: "Mother's Identifier" at a specific index 1427 * 1428 * @param rep The repetition index (0-indexed) 1429 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1430 */ 1431 public CX insertPid21_MotherSIdentifier(int rep) throws HL7Exception { 1432 return (CX) super.insertRepetition(21, rep); 1433 } 1434 1435 1436 /** 1437 * Removes a repetition of 1438 * PID-21: "Mother's Identifier" at a specific index 1439 * 1440 * @param rep The repetition index (0-indexed) 1441 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1442 */ 1443 public CX removeMotherSIdentifier(int rep) throws HL7Exception { 1444 return (CX) super.removeRepetition(21, rep); 1445 } 1446 1447 1448 /** 1449 * Removes a repetition of 1450 * PID-21: "Mother's Identifier" at a specific index 1451 * 1452 * @param rep The repetition index (0-indexed) 1453 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1454 */ 1455 public CX removePid21_MotherSIdentifier(int rep) throws HL7Exception { 1456 return (CX) super.removeRepetition(21, rep); 1457 } 1458 1459 1460 1461 /** 1462 * Returns all repetitions of Ethnic Group (PID-22). 1463 */ 1464 public CE[] getEthnicGroup() { 1465 CE[] retVal = this.getTypedField(22, new CE[0]); 1466 return retVal; 1467 } 1468 1469 1470 /** 1471 * Returns all repetitions of Ethnic Group (PID-22). 1472 */ 1473 public CE[] getPid22_EthnicGroup() { 1474 CE[] retVal = this.getTypedField(22, new CE[0]); 1475 return retVal; 1476 } 1477 1478 1479 /** 1480 * Returns a count of the current number of repetitions of Ethnic Group (PID-22). 1481 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1482 * it will return zero. 1483 */ 1484 public int getEthnicGroupReps() { 1485 return this.getReps(22); 1486 } 1487 1488 1489 /** 1490 * Returns a specific repetition of 1491 * PID-22: "Ethnic Group" - creates it if necessary 1492 * 1493 * @param rep The repetition index (0-indexed) 1494 */ 1495 public CE getEthnicGroup(int rep) { 1496 CE retVal = this.getTypedField(22, rep); 1497 return retVal; 1498 } 1499 1500 /** 1501 * Returns a specific repetition of 1502 * PID-22: "Ethnic Group" - creates it if necessary 1503 * 1504 * @param rep The repetition index (0-indexed) 1505 */ 1506 public CE getPid22_EthnicGroup(int rep) { 1507 CE retVal = this.getTypedField(22, rep); 1508 return retVal; 1509 } 1510 1511 /** 1512 * Returns a count of the current number of repetitions of Ethnic Group (PID-22). 1513 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1514 * it will return zero. 1515 */ 1516 public int getPid22_EthnicGroupReps() { 1517 return this.getReps(22); 1518 } 1519 1520 1521 /** 1522 * Inserts a repetition of 1523 * PID-22: "Ethnic Group" at a specific index 1524 * 1525 * @param rep The repetition index (0-indexed) 1526 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1527 */ 1528 public CE insertEthnicGroup(int rep) throws HL7Exception { 1529 return (CE) super.insertRepetition(22, rep); 1530 } 1531 1532 1533 /** 1534 * Inserts a repetition of 1535 * PID-22: "Ethnic Group" at a specific index 1536 * 1537 * @param rep The repetition index (0-indexed) 1538 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1539 */ 1540 public CE insertPid22_EthnicGroup(int rep) throws HL7Exception { 1541 return (CE) super.insertRepetition(22, rep); 1542 } 1543 1544 1545 /** 1546 * Removes a repetition of 1547 * PID-22: "Ethnic Group" at a specific index 1548 * 1549 * @param rep The repetition index (0-indexed) 1550 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1551 */ 1552 public CE removeEthnicGroup(int rep) throws HL7Exception { 1553 return (CE) super.removeRepetition(22, rep); 1554 } 1555 1556 1557 /** 1558 * Removes a repetition of 1559 * PID-22: "Ethnic Group" at a specific index 1560 * 1561 * @param rep The repetition index (0-indexed) 1562 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1563 */ 1564 public CE removePid22_EthnicGroup(int rep) throws HL7Exception { 1565 return (CE) super.removeRepetition(22, rep); 1566 } 1567 1568 1569 1570 1571 /** 1572 * Returns 1573 * PID-23: "Birth Place" - creates it if necessary 1574 */ 1575 public ST getBirthPlace() { 1576 ST retVal = this.getTypedField(23, 0); 1577 return retVal; 1578 } 1579 1580 /** 1581 * Returns 1582 * PID-23: "Birth Place" - creates it if necessary 1583 */ 1584 public ST getPid23_BirthPlace() { 1585 ST retVal = this.getTypedField(23, 0); 1586 return retVal; 1587 } 1588 1589 1590 1591 /** 1592 * Returns 1593 * PID-24: "Multiple Birth Indicator" - creates it if necessary 1594 */ 1595 public ID getMultipleBirthIndicator() { 1596 ID retVal = this.getTypedField(24, 0); 1597 return retVal; 1598 } 1599 1600 /** 1601 * Returns 1602 * PID-24: "Multiple Birth Indicator" - creates it if necessary 1603 */ 1604 public ID getPid24_MultipleBirthIndicator() { 1605 ID retVal = this.getTypedField(24, 0); 1606 return retVal; 1607 } 1608 1609 1610 1611 /** 1612 * Returns 1613 * PID-25: "Birth Order" - creates it if necessary 1614 */ 1615 public NM getBirthOrder() { 1616 NM retVal = this.getTypedField(25, 0); 1617 return retVal; 1618 } 1619 1620 /** 1621 * Returns 1622 * PID-25: "Birth Order" - creates it if necessary 1623 */ 1624 public NM getPid25_BirthOrder() { 1625 NM retVal = this.getTypedField(25, 0); 1626 return retVal; 1627 } 1628 1629 1630 /** 1631 * Returns all repetitions of Citizenship (PID-26). 1632 */ 1633 public CE[] getCitizenship() { 1634 CE[] retVal = this.getTypedField(26, new CE[0]); 1635 return retVal; 1636 } 1637 1638 1639 /** 1640 * Returns all repetitions of Citizenship (PID-26). 1641 */ 1642 public CE[] getPid26_Citizenship() { 1643 CE[] retVal = this.getTypedField(26, new CE[0]); 1644 return retVal; 1645 } 1646 1647 1648 /** 1649 * Returns a count of the current number of repetitions of Citizenship (PID-26). 1650 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1651 * it will return zero. 1652 */ 1653 public int getCitizenshipReps() { 1654 return this.getReps(26); 1655 } 1656 1657 1658 /** 1659 * Returns a specific repetition of 1660 * PID-26: "Citizenship" - creates it if necessary 1661 * 1662 * @param rep The repetition index (0-indexed) 1663 */ 1664 public CE getCitizenship(int rep) { 1665 CE retVal = this.getTypedField(26, rep); 1666 return retVal; 1667 } 1668 1669 /** 1670 * Returns a specific repetition of 1671 * PID-26: "Citizenship" - creates it if necessary 1672 * 1673 * @param rep The repetition index (0-indexed) 1674 */ 1675 public CE getPid26_Citizenship(int rep) { 1676 CE retVal = this.getTypedField(26, rep); 1677 return retVal; 1678 } 1679 1680 /** 1681 * Returns a count of the current number of repetitions of Citizenship (PID-26). 1682 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1683 * it will return zero. 1684 */ 1685 public int getPid26_CitizenshipReps() { 1686 return this.getReps(26); 1687 } 1688 1689 1690 /** 1691 * Inserts a repetition of 1692 * PID-26: "Citizenship" at a specific index 1693 * 1694 * @param rep The repetition index (0-indexed) 1695 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1696 */ 1697 public CE insertCitizenship(int rep) throws HL7Exception { 1698 return (CE) super.insertRepetition(26, rep); 1699 } 1700 1701 1702 /** 1703 * Inserts a repetition of 1704 * PID-26: "Citizenship" at a specific index 1705 * 1706 * @param rep The repetition index (0-indexed) 1707 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1708 */ 1709 public CE insertPid26_Citizenship(int rep) throws HL7Exception { 1710 return (CE) super.insertRepetition(26, rep); 1711 } 1712 1713 1714 /** 1715 * Removes a repetition of 1716 * PID-26: "Citizenship" at a specific index 1717 * 1718 * @param rep The repetition index (0-indexed) 1719 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1720 */ 1721 public CE removeCitizenship(int rep) throws HL7Exception { 1722 return (CE) super.removeRepetition(26, rep); 1723 } 1724 1725 1726 /** 1727 * Removes a repetition of 1728 * PID-26: "Citizenship" at a specific index 1729 * 1730 * @param rep The repetition index (0-indexed) 1731 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1732 */ 1733 public CE removePid26_Citizenship(int rep) throws HL7Exception { 1734 return (CE) super.removeRepetition(26, rep); 1735 } 1736 1737 1738 1739 1740 /** 1741 * Returns 1742 * PID-27: "Veterans Military Status" - creates it if necessary 1743 */ 1744 public CE getVeteransMilitaryStatus() { 1745 CE retVal = this.getTypedField(27, 0); 1746 return retVal; 1747 } 1748 1749 /** 1750 * Returns 1751 * PID-27: "Veterans Military Status" - creates it if necessary 1752 */ 1753 public CE getPid27_VeteransMilitaryStatus() { 1754 CE retVal = this.getTypedField(27, 0); 1755 return retVal; 1756 } 1757 1758 1759 1760 /** 1761 * Returns 1762 * PID-28: "Nationality" - creates it if necessary 1763 */ 1764 public CE getNationality() { 1765 CE retVal = this.getTypedField(28, 0); 1766 return retVal; 1767 } 1768 1769 /** 1770 * Returns 1771 * PID-28: "Nationality" - creates it if necessary 1772 */ 1773 public CE getPid28_Nationality() { 1774 CE retVal = this.getTypedField(28, 0); 1775 return retVal; 1776 } 1777 1778 1779 1780 /** 1781 * Returns 1782 * PID-29: "Patient Death Date and Time" - creates it if necessary 1783 */ 1784 public TS getPatientDeathDateAndTime() { 1785 TS retVal = this.getTypedField(29, 0); 1786 return retVal; 1787 } 1788 1789 /** 1790 * Returns 1791 * PID-29: "Patient Death Date and Time" - creates it if necessary 1792 */ 1793 public TS getPid29_PatientDeathDateAndTime() { 1794 TS retVal = this.getTypedField(29, 0); 1795 return retVal; 1796 } 1797 1798 1799 1800 /** 1801 * Returns 1802 * PID-30: "Patient Death Indicator" - creates it if necessary 1803 */ 1804 public ID getPatientDeathIndicator() { 1805 ID retVal = this.getTypedField(30, 0); 1806 return retVal; 1807 } 1808 1809 /** 1810 * Returns 1811 * PID-30: "Patient Death Indicator" - creates it if necessary 1812 */ 1813 public ID getPid30_PatientDeathIndicator() { 1814 ID retVal = this.getTypedField(30, 0); 1815 return retVal; 1816 } 1817 1818 1819 1820 /** 1821 * Returns 1822 * PID-31: "Identity Unknown Indicator" - creates it if necessary 1823 */ 1824 public ID getIdentityUnknownIndicator() { 1825 ID retVal = this.getTypedField(31, 0); 1826 return retVal; 1827 } 1828 1829 /** 1830 * Returns 1831 * PID-31: "Identity Unknown Indicator" - creates it if necessary 1832 */ 1833 public ID getPid31_IdentityUnknownIndicator() { 1834 ID retVal = this.getTypedField(31, 0); 1835 return retVal; 1836 } 1837 1838 1839 /** 1840 * Returns all repetitions of Identity Reliability Code (PID-32). 1841 */ 1842 public IS[] getIdentityReliabilityCode() { 1843 IS[] retVal = this.getTypedField(32, new IS[0]); 1844 return retVal; 1845 } 1846 1847 1848 /** 1849 * Returns all repetitions of Identity Reliability Code (PID-32). 1850 */ 1851 public IS[] getPid32_IdentityReliabilityCode() { 1852 IS[] retVal = this.getTypedField(32, new IS[0]); 1853 return retVal; 1854 } 1855 1856 1857 /** 1858 * Returns a count of the current number of repetitions of Identity Reliability Code (PID-32). 1859 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1860 * it will return zero. 1861 */ 1862 public int getIdentityReliabilityCodeReps() { 1863 return this.getReps(32); 1864 } 1865 1866 1867 /** 1868 * Returns a specific repetition of 1869 * PID-32: "Identity Reliability Code" - creates it if necessary 1870 * 1871 * @param rep The repetition index (0-indexed) 1872 */ 1873 public IS getIdentityReliabilityCode(int rep) { 1874 IS retVal = this.getTypedField(32, rep); 1875 return retVal; 1876 } 1877 1878 /** 1879 * Returns a specific repetition of 1880 * PID-32: "Identity Reliability Code" - creates it if necessary 1881 * 1882 * @param rep The repetition index (0-indexed) 1883 */ 1884 public IS getPid32_IdentityReliabilityCode(int rep) { 1885 IS retVal = this.getTypedField(32, rep); 1886 return retVal; 1887 } 1888 1889 /** 1890 * Returns a count of the current number of repetitions of Identity Reliability Code (PID-32). 1891 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1892 * it will return zero. 1893 */ 1894 public int getPid32_IdentityReliabilityCodeReps() { 1895 return this.getReps(32); 1896 } 1897 1898 1899 /** 1900 * Inserts a repetition of 1901 * PID-32: "Identity Reliability Code" at a specific index 1902 * 1903 * @param rep The repetition index (0-indexed) 1904 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1905 */ 1906 public IS insertIdentityReliabilityCode(int rep) throws HL7Exception { 1907 return (IS) super.insertRepetition(32, rep); 1908 } 1909 1910 1911 /** 1912 * Inserts a repetition of 1913 * PID-32: "Identity Reliability Code" at a specific index 1914 * 1915 * @param rep The repetition index (0-indexed) 1916 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1917 */ 1918 public IS insertPid32_IdentityReliabilityCode(int rep) throws HL7Exception { 1919 return (IS) super.insertRepetition(32, rep); 1920 } 1921 1922 1923 /** 1924 * Removes a repetition of 1925 * PID-32: "Identity Reliability Code" at a specific index 1926 * 1927 * @param rep The repetition index (0-indexed) 1928 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1929 */ 1930 public IS removeIdentityReliabilityCode(int rep) throws HL7Exception { 1931 return (IS) super.removeRepetition(32, rep); 1932 } 1933 1934 1935 /** 1936 * Removes a repetition of 1937 * PID-32: "Identity Reliability Code" at a specific index 1938 * 1939 * @param rep The repetition index (0-indexed) 1940 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1941 */ 1942 public IS removePid32_IdentityReliabilityCode(int rep) throws HL7Exception { 1943 return (IS) super.removeRepetition(32, rep); 1944 } 1945 1946 1947 1948 1949 /** 1950 * Returns 1951 * PID-33: "Last Update Date/Time" - creates it if necessary 1952 */ 1953 public TS getLastUpdateDateTime() { 1954 TS retVal = this.getTypedField(33, 0); 1955 return retVal; 1956 } 1957 1958 /** 1959 * Returns 1960 * PID-33: "Last Update Date/Time" - creates it if necessary 1961 */ 1962 public TS getPid33_LastUpdateDateTime() { 1963 TS retVal = this.getTypedField(33, 0); 1964 return retVal; 1965 } 1966 1967 1968 1969 /** 1970 * Returns 1971 * PID-34: "Last Update Facility" - creates it if necessary 1972 */ 1973 public HD getLastUpdateFacility() { 1974 HD retVal = this.getTypedField(34, 0); 1975 return retVal; 1976 } 1977 1978 /** 1979 * Returns 1980 * PID-34: "Last Update Facility" - creates it if necessary 1981 */ 1982 public HD getPid34_LastUpdateFacility() { 1983 HD retVal = this.getTypedField(34, 0); 1984 return retVal; 1985 } 1986 1987 1988 1989 /** 1990 * Returns 1991 * PID-35: "Species Code" - creates it if necessary 1992 */ 1993 public CE getSpeciesCode() { 1994 CE retVal = this.getTypedField(35, 0); 1995 return retVal; 1996 } 1997 1998 /** 1999 * Returns 2000 * PID-35: "Species Code" - creates it if necessary 2001 */ 2002 public CE getPid35_SpeciesCode() { 2003 CE retVal = this.getTypedField(35, 0); 2004 return retVal; 2005 } 2006 2007 2008 2009 /** 2010 * Returns 2011 * PID-36: "Breed Code" - creates it if necessary 2012 */ 2013 public CE getBreedCode() { 2014 CE retVal = this.getTypedField(36, 0); 2015 return retVal; 2016 } 2017 2018 /** 2019 * Returns 2020 * PID-36: "Breed Code" - creates it if necessary 2021 */ 2022 public CE getPid36_BreedCode() { 2023 CE retVal = this.getTypedField(36, 0); 2024 return retVal; 2025 } 2026 2027 2028 2029 /** 2030 * Returns 2031 * PID-37: "Strain" - creates it if necessary 2032 */ 2033 public ST getStrain() { 2034 ST retVal = this.getTypedField(37, 0); 2035 return retVal; 2036 } 2037 2038 /** 2039 * Returns 2040 * PID-37: "Strain" - creates it if necessary 2041 */ 2042 public ST getPid37_Strain() { 2043 ST retVal = this.getTypedField(37, 0); 2044 return retVal; 2045 } 2046 2047 2048 2049 /** 2050 * Returns 2051 * PID-38: "Production Class Code" - creates it if necessary 2052 */ 2053 public CE getProductionClassCode() { 2054 CE retVal = this.getTypedField(38, 0); 2055 return retVal; 2056 } 2057 2058 /** 2059 * Returns 2060 * PID-38: "Production Class Code" - creates it if necessary 2061 */ 2062 public CE getPid38_ProductionClassCode() { 2063 CE retVal = this.getTypedField(38, 0); 2064 return retVal; 2065 } 2066 2067 2068 /** 2069 * Returns all repetitions of Tribal Citizenship (PID-39). 2070 */ 2071 public CWE[] getTribalCitizenship() { 2072 CWE[] retVal = this.getTypedField(39, new CWE[0]); 2073 return retVal; 2074 } 2075 2076 2077 /** 2078 * Returns all repetitions of Tribal Citizenship (PID-39). 2079 */ 2080 public CWE[] getPid39_TribalCitizenship() { 2081 CWE[] retVal = this.getTypedField(39, new CWE[0]); 2082 return retVal; 2083 } 2084 2085 2086 /** 2087 * Returns a count of the current number of repetitions of Tribal Citizenship (PID-39). 2088 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2089 * it will return zero. 2090 */ 2091 public int getTribalCitizenshipReps() { 2092 return this.getReps(39); 2093 } 2094 2095 2096 /** 2097 * Returns a specific repetition of 2098 * PID-39: "Tribal Citizenship" - creates it if necessary 2099 * 2100 * @param rep The repetition index (0-indexed) 2101 */ 2102 public CWE getTribalCitizenship(int rep) { 2103 CWE retVal = this.getTypedField(39, rep); 2104 return retVal; 2105 } 2106 2107 /** 2108 * Returns a specific repetition of 2109 * PID-39: "Tribal Citizenship" - creates it if necessary 2110 * 2111 * @param rep The repetition index (0-indexed) 2112 */ 2113 public CWE getPid39_TribalCitizenship(int rep) { 2114 CWE retVal = this.getTypedField(39, rep); 2115 return retVal; 2116 } 2117 2118 /** 2119 * Returns a count of the current number of repetitions of Tribal Citizenship (PID-39). 2120 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 2121 * it will return zero. 2122 */ 2123 public int getPid39_TribalCitizenshipReps() { 2124 return this.getReps(39); 2125 } 2126 2127 2128 /** 2129 * Inserts a repetition of 2130 * PID-39: "Tribal Citizenship" at a specific index 2131 * 2132 * @param rep The repetition index (0-indexed) 2133 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2134 */ 2135 public CWE insertTribalCitizenship(int rep) throws HL7Exception { 2136 return (CWE) super.insertRepetition(39, rep); 2137 } 2138 2139 2140 /** 2141 * Inserts a repetition of 2142 * PID-39: "Tribal Citizenship" at a specific index 2143 * 2144 * @param rep The repetition index (0-indexed) 2145 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2146 */ 2147 public CWE insertPid39_TribalCitizenship(int rep) throws HL7Exception { 2148 return (CWE) super.insertRepetition(39, rep); 2149 } 2150 2151 2152 /** 2153 * Removes a repetition of 2154 * PID-39: "Tribal Citizenship" at a specific index 2155 * 2156 * @param rep The repetition index (0-indexed) 2157 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2158 */ 2159 public CWE removeTribalCitizenship(int rep) throws HL7Exception { 2160 return (CWE) super.removeRepetition(39, rep); 2161 } 2162 2163 2164 /** 2165 * Removes a repetition of 2166 * PID-39: "Tribal Citizenship" at a specific index 2167 * 2168 * @param rep The repetition index (0-indexed) 2169 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 2170 */ 2171 public CWE removePid39_TribalCitizenship(int rep) throws HL7Exception { 2172 return (CWE) super.removeRepetition(39, rep); 2173 } 2174 2175 2176 2177 2178 2179 2180 /** {@inheritDoc} */ 2181 protected Type createNewTypeWithoutReflection(int field) { 2182 switch (field) { 2183 case 0: return new SI(getMessage()); 2184 case 1: return new CX(getMessage()); 2185 case 2: return new CX(getMessage()); 2186 case 3: return new CX(getMessage()); 2187 case 4: return new XPN(getMessage()); 2188 case 5: return new XPN(getMessage()); 2189 case 6: return new TS(getMessage()); 2190 case 7: return new IS(getMessage(), new Integer( 1 )); 2191 case 8: return new XPN(getMessage()); 2192 case 9: return new CE(getMessage()); 2193 case 10: return new XAD(getMessage()); 2194 case 11: return new IS(getMessage(), new Integer( 289 )); 2195 case 12: return new XTN(getMessage()); 2196 case 13: return new XTN(getMessage()); 2197 case 14: return new CE(getMessage()); 2198 case 15: return new CE(getMessage()); 2199 case 16: return new CE(getMessage()); 2200 case 17: return new CX(getMessage()); 2201 case 18: return new ST(getMessage()); 2202 case 19: return new DLN(getMessage()); 2203 case 20: return new CX(getMessage()); 2204 case 21: return new CE(getMessage()); 2205 case 22: return new ST(getMessage()); 2206 case 23: return new ID(getMessage(), new Integer( 136 )); 2207 case 24: return new NM(getMessage()); 2208 case 25: return new CE(getMessage()); 2209 case 26: return new CE(getMessage()); 2210 case 27: return new CE(getMessage()); 2211 case 28: return new TS(getMessage()); 2212 case 29: return new ID(getMessage(), new Integer( 136 )); 2213 case 30: return new ID(getMessage(), new Integer( 136 )); 2214 case 31: return new IS(getMessage(), new Integer( 445 )); 2215 case 32: return new TS(getMessage()); 2216 case 33: return new HD(getMessage()); 2217 case 34: return new CE(getMessage()); 2218 case 35: return new CE(getMessage()); 2219 case 36: return new ST(getMessage()); 2220 case 37: return new CE(getMessage()); 2221 case 38: return new CWE(getMessage()); 2222 default: return null; 2223 } 2224 } 2225 2226 2227} 2228