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.v23.segment; 035 036// import ca.uhn.hl7v2.model.v23.group.*; 037import ca.uhn.hl7v2.model.v23.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 - Patient ID (SI) <b>optional </b> 053 * <li>PID-2: Patient ID (External ID) (CX) <b>optional </b> 054 * <li>PID-3: Patient ID (Internal ID) (CX) <b> repeating</b> 055 * <li>PID-4: Alternate Patient ID (CX) <b>optional </b> 056 * <li>PID-5: Patient Name (XPN) <b> repeating</b> 057 * <li>PID-6: Mother's Maiden Name (XPN) <b>optional </b> 058 * <li>PID-7: Date of Birth (TS) <b>optional </b> 059 * <li>PID-8: Sex (IS) <b>optional </b> 060 * <li>PID-9: Patient Alias (XPN) <b>optional repeating</b> 061 * <li>PID-10: Race (IS) <b>optional </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 (IS) <b>optional repeating</b> 068 * <li>PID-17: Religion (IS) <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 (DLN) <b>optional </b> 072 * <li>PID-21: Mother's Identifier (CX) <b>optional </b> 073 * <li>PID-22: Ethnic Group (IS) <b>optional </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 (IS) <b>optional </b> 078 * <li>PID-27: Veterans Military Status (CE) <b>optional </b> 079 * <li>PID-28: Nationality Code (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 * </ul> 083 */ 084@SuppressWarnings("unused") 085public class PID extends AbstractSegment { 086 087 /** 088 * Creates a new PID segment 089 */ 090 public PID(Group parent, ModelClassFactory factory) { 091 super(parent, factory); 092 init(factory); 093 } 094 095 private void init(ModelClassFactory factory) { 096 try { 097 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - Patient ID"); 098 this.add(CX.class, false, 1, 16, new Object[]{ getMessage() }, "Patient ID (External ID)"); 099 this.add(CX.class, true, 0, 20, new Object[]{ getMessage() }, "Patient ID (Internal ID)"); 100 this.add(CX.class, false, 1, 12, new Object[]{ getMessage() }, "Alternate Patient ID"); 101 this.add(XPN.class, true, -1, 48, new Object[]{ getMessage() }, "Patient Name"); 102 this.add(XPN.class, false, 1, 48, new Object[]{ getMessage() }, "Mother's Maiden Name"); 103 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date of Birth"); 104 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Sex"); 105 this.add(XPN.class, false, 0, 48, new Object[]{ getMessage() }, "Patient Alias"); 106 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(5) }, "Race"); 107 this.add(XAD.class, false, 0, 106, new Object[]{ getMessage() }, "Patient Address"); 108 this.add(IS.class, false, 1, 4, new Object[]{ getMessage(), new Integer(0) }, "County Code"); 109 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone Number - Home"); 110 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone Number - Business"); 111 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Primary Language"); 112 this.add(IS.class, false, 0, 1, new Object[]{ getMessage(), new Integer(2) }, "Marital Status"); 113 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(6) }, "Religion"); 114 this.add(CX.class, false, 1, 20, new Object[]{ getMessage() }, "Patient Account Number"); 115 this.add(ST.class, false, 1, 16, new Object[]{ getMessage() }, "SSN Number - Patient"); 116 this.add(DLN.class, false, 1, 25, new Object[]{ getMessage() }, "Driver's License Number"); 117 this.add(CX.class, false, 1, 20, new Object[]{ getMessage() }, "Mother's Identifier"); 118 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(189) }, "Ethnic Group"); 119 this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "Birth Place"); 120 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(136) }, "Multiple Birth Indicator"); 121 this.add(NM.class, false, 1, 2, new Object[]{ getMessage() }, "Birth Order"); 122 this.add(IS.class, false, 1, 4, new Object[]{ getMessage(), new Integer(171) }, "Citizenship"); 123 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Veterans Military Status"); 124 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Nationality Code"); 125 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Patient Death Date and Time"); 126 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Patient Death Indicator"); 127 } catch(HL7Exception e) { 128 log.error("Unexpected error creating PID - this is probably a bug in the source code generator.", e); 129 } 130 } 131 132 133 134 /** 135 * Returns 136 * PID-1: "Set ID - Patient ID" - creates it if necessary 137 */ 138 public SI getSetIDPatientID() { 139 SI retVal = this.getTypedField(1, 0); 140 return retVal; 141 } 142 143 /** 144 * Returns 145 * PID-1: "Set ID - Patient ID" - creates it if necessary 146 */ 147 public SI getPid1_SetIDPatientID() { 148 SI retVal = this.getTypedField(1, 0); 149 return retVal; 150 } 151 152 153 154 /** 155 * Returns 156 * PID-2: "Patient ID (External ID)" - creates it if necessary 157 */ 158 public CX getPatientIDExternalID() { 159 CX retVal = this.getTypedField(2, 0); 160 return retVal; 161 } 162 163 /** 164 * Returns 165 * PID-2: "Patient ID (External ID)" - creates it if necessary 166 */ 167 public CX getPid2_PatientIDExternalID() { 168 CX retVal = this.getTypedField(2, 0); 169 return retVal; 170 } 171 172 173 /** 174 * Returns all repetitions of Patient ID (Internal ID) (PID-3). 175 */ 176 public CX[] getPatientIDInternalID() { 177 CX[] retVal = this.getTypedField(3, new CX[0]); 178 return retVal; 179 } 180 181 182 /** 183 * Returns all repetitions of Patient ID (Internal ID) (PID-3). 184 */ 185 public CX[] getPid3_PatientIDInternalID() { 186 CX[] retVal = this.getTypedField(3, new CX[0]); 187 return retVal; 188 } 189 190 191 /** 192 * Returns a count of the current number of repetitions of Patient ID (Internal ID) (PID-3). 193 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 194 * it will return zero. 195 */ 196 public int getPatientIDInternalIDReps() { 197 return this.getReps(3); 198 } 199 200 201 /** 202 * Returns a specific repetition of 203 * PID-3: "Patient ID (Internal ID)" - creates it if necessary 204 * 205 * @param rep The repetition index (0-indexed) 206 */ 207 public CX getPatientIDInternalID(int rep) { 208 CX retVal = this.getTypedField(3, rep); 209 return retVal; 210 } 211 212 /** 213 * Returns a specific repetition of 214 * PID-3: "Patient ID (Internal ID)" - creates it if necessary 215 * 216 * @param rep The repetition index (0-indexed) 217 */ 218 public CX getPid3_PatientIDInternalID(int rep) { 219 CX retVal = this.getTypedField(3, rep); 220 return retVal; 221 } 222 223 /** 224 * Returns a count of the current number of repetitions of Patient ID (Internal ID) (PID-3). 225 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 226 * it will return zero. 227 */ 228 public int getPid3_PatientIDInternalIDReps() { 229 return this.getReps(3); 230 } 231 232 233 /** 234 * Inserts a repetition of 235 * PID-3: "Patient ID (Internal ID)" at a specific index 236 * 237 * @param rep The repetition index (0-indexed) 238 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 239 */ 240 public CX insertPatientIDInternalID(int rep) throws HL7Exception { 241 return (CX) super.insertRepetition(3, rep); 242 } 243 244 245 /** 246 * Inserts a repetition of 247 * PID-3: "Patient ID (Internal ID)" at a specific index 248 * 249 * @param rep The repetition index (0-indexed) 250 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 251 */ 252 public CX insertPid3_PatientIDInternalID(int rep) throws HL7Exception { 253 return (CX) super.insertRepetition(3, rep); 254 } 255 256 257 /** 258 * Removes a repetition of 259 * PID-3: "Patient ID (Internal ID)" at a specific index 260 * 261 * @param rep The repetition index (0-indexed) 262 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 263 */ 264 public CX removePatientIDInternalID(int rep) throws HL7Exception { 265 return (CX) super.removeRepetition(3, rep); 266 } 267 268 269 /** 270 * Removes a repetition of 271 * PID-3: "Patient ID (Internal ID)" at a specific index 272 * 273 * @param rep The repetition index (0-indexed) 274 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 275 */ 276 public CX removePid3_PatientIDInternalID(int rep) throws HL7Exception { 277 return (CX) super.removeRepetition(3, rep); 278 } 279 280 281 282 283 /** 284 * Returns 285 * PID-4: "Alternate Patient ID" - creates it if necessary 286 */ 287 public CX getAlternatePatientID() { 288 CX retVal = this.getTypedField(4, 0); 289 return retVal; 290 } 291 292 /** 293 * Returns 294 * PID-4: "Alternate Patient ID" - creates it if necessary 295 */ 296 public CX getPid4_AlternatePatientID() { 297 CX retVal = this.getTypedField(4, 0); 298 return retVal; 299 } 300 301 302 /** 303 * Returns all repetitions of Patient Name (PID-5). 304 */ 305 public XPN[] getPatientName() { 306 XPN[] retVal = this.getTypedField(5, new XPN[0]); 307 return retVal; 308 } 309 310 311 /** 312 * Returns all repetitions of Patient Name (PID-5). 313 */ 314 public XPN[] getPid5_PatientName() { 315 XPN[] retVal = this.getTypedField(5, new XPN[0]); 316 return retVal; 317 } 318 319 320 /** 321 * Returns a count of the current number of repetitions of Patient Name (PID-5). 322 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 323 * it will return zero. 324 */ 325 public int getPatientNameReps() { 326 return this.getReps(5); 327 } 328 329 330 /** 331 * Returns a specific repetition of 332 * PID-5: "Patient Name" - creates it if necessary 333 * 334 * @param rep The repetition index (0-indexed) 335 */ 336 public XPN getPatientName(int rep) { 337 XPN retVal = this.getTypedField(5, rep); 338 return retVal; 339 } 340 341 /** 342 * Returns a specific repetition of 343 * PID-5: "Patient Name" - creates it if necessary 344 * 345 * @param rep The repetition index (0-indexed) 346 */ 347 public XPN getPid5_PatientName(int rep) { 348 XPN retVal = this.getTypedField(5, rep); 349 return retVal; 350 } 351 352 /** 353 * Returns a count of the current number of repetitions of Patient Name (PID-5). 354 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 355 * it will return zero. 356 */ 357 public int getPid5_PatientNameReps() { 358 return this.getReps(5); 359 } 360 361 362 /** 363 * Inserts a repetition of 364 * PID-5: "Patient Name" at a specific index 365 * 366 * @param rep The repetition index (0-indexed) 367 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 368 */ 369 public XPN insertPatientName(int rep) throws HL7Exception { 370 return (XPN) super.insertRepetition(5, rep); 371 } 372 373 374 /** 375 * Inserts a repetition of 376 * PID-5: "Patient Name" at a specific index 377 * 378 * @param rep The repetition index (0-indexed) 379 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 380 */ 381 public XPN insertPid5_PatientName(int rep) throws HL7Exception { 382 return (XPN) super.insertRepetition(5, rep); 383 } 384 385 386 /** 387 * Removes a repetition of 388 * PID-5: "Patient Name" at a specific index 389 * 390 * @param rep The repetition index (0-indexed) 391 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 392 */ 393 public XPN removePatientName(int rep) throws HL7Exception { 394 return (XPN) super.removeRepetition(5, rep); 395 } 396 397 398 /** 399 * Removes a repetition of 400 * PID-5: "Patient Name" at a specific index 401 * 402 * @param rep The repetition index (0-indexed) 403 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 404 */ 405 public XPN removePid5_PatientName(int rep) throws HL7Exception { 406 return (XPN) super.removeRepetition(5, rep); 407 } 408 409 410 411 412 /** 413 * Returns 414 * PID-6: "Mother's Maiden Name" - creates it if necessary 415 */ 416 public XPN getMotherSMaidenName() { 417 XPN retVal = this.getTypedField(6, 0); 418 return retVal; 419 } 420 421 /** 422 * Returns 423 * PID-6: "Mother's Maiden Name" - creates it if necessary 424 */ 425 public XPN getPid6_MotherSMaidenName() { 426 XPN retVal = this.getTypedField(6, 0); 427 return retVal; 428 } 429 430 431 432 /** 433 * Returns 434 * PID-7: "Date of Birth" - creates it if necessary 435 */ 436 public TS getDateOfBirth() { 437 TS retVal = this.getTypedField(7, 0); 438 return retVal; 439 } 440 441 /** 442 * Returns 443 * PID-7: "Date of Birth" - creates it if necessary 444 */ 445 public TS getPid7_DateOfBirth() { 446 TS retVal = this.getTypedField(7, 0); 447 return retVal; 448 } 449 450 451 452 /** 453 * Returns 454 * PID-8: "Sex" - creates it if necessary 455 */ 456 public IS getSex() { 457 IS retVal = this.getTypedField(8, 0); 458 return retVal; 459 } 460 461 /** 462 * Returns 463 * PID-8: "Sex" - creates it if necessary 464 */ 465 public IS getPid8_Sex() { 466 IS retVal = this.getTypedField(8, 0); 467 return retVal; 468 } 469 470 471 /** 472 * Returns all repetitions of Patient Alias (PID-9). 473 */ 474 public XPN[] getPatientAlias() { 475 XPN[] retVal = this.getTypedField(9, new XPN[0]); 476 return retVal; 477 } 478 479 480 /** 481 * Returns all repetitions of Patient Alias (PID-9). 482 */ 483 public XPN[] getPid9_PatientAlias() { 484 XPN[] retVal = this.getTypedField(9, new XPN[0]); 485 return retVal; 486 } 487 488 489 /** 490 * Returns a count of the current number of repetitions of Patient Alias (PID-9). 491 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 492 * it will return zero. 493 */ 494 public int getPatientAliasReps() { 495 return this.getReps(9); 496 } 497 498 499 /** 500 * Returns a specific repetition of 501 * PID-9: "Patient Alias" - creates it if necessary 502 * 503 * @param rep The repetition index (0-indexed) 504 */ 505 public XPN getPatientAlias(int rep) { 506 XPN retVal = this.getTypedField(9, rep); 507 return retVal; 508 } 509 510 /** 511 * Returns a specific repetition of 512 * PID-9: "Patient Alias" - creates it if necessary 513 * 514 * @param rep The repetition index (0-indexed) 515 */ 516 public XPN getPid9_PatientAlias(int rep) { 517 XPN retVal = this.getTypedField(9, rep); 518 return retVal; 519 } 520 521 /** 522 * Returns a count of the current number of repetitions of Patient Alias (PID-9). 523 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 524 * it will return zero. 525 */ 526 public int getPid9_PatientAliasReps() { 527 return this.getReps(9); 528 } 529 530 531 /** 532 * Inserts a repetition of 533 * PID-9: "Patient Alias" at a specific index 534 * 535 * @param rep The repetition index (0-indexed) 536 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 537 */ 538 public XPN insertPatientAlias(int rep) throws HL7Exception { 539 return (XPN) super.insertRepetition(9, rep); 540 } 541 542 543 /** 544 * Inserts a repetition of 545 * PID-9: "Patient Alias" at a specific index 546 * 547 * @param rep The repetition index (0-indexed) 548 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 549 */ 550 public XPN insertPid9_PatientAlias(int rep) throws HL7Exception { 551 return (XPN) super.insertRepetition(9, rep); 552 } 553 554 555 /** 556 * Removes a repetition of 557 * PID-9: "Patient Alias" at a specific index 558 * 559 * @param rep The repetition index (0-indexed) 560 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 561 */ 562 public XPN removePatientAlias(int rep) throws HL7Exception { 563 return (XPN) super.removeRepetition(9, rep); 564 } 565 566 567 /** 568 * Removes a repetition of 569 * PID-9: "Patient Alias" at a specific index 570 * 571 * @param rep The repetition index (0-indexed) 572 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 573 */ 574 public XPN removePid9_PatientAlias(int rep) throws HL7Exception { 575 return (XPN) super.removeRepetition(9, rep); 576 } 577 578 579 580 581 /** 582 * Returns 583 * PID-10: "Race" - creates it if necessary 584 */ 585 public IS getRace() { 586 IS retVal = this.getTypedField(10, 0); 587 return retVal; 588 } 589 590 /** 591 * Returns 592 * PID-10: "Race" - creates it if necessary 593 */ 594 public IS getPid10_Race() { 595 IS retVal = this.getTypedField(10, 0); 596 return retVal; 597 } 598 599 600 /** 601 * Returns all repetitions of Patient Address (PID-11). 602 */ 603 public XAD[] getPatientAddress() { 604 XAD[] retVal = this.getTypedField(11, new XAD[0]); 605 return retVal; 606 } 607 608 609 /** 610 * Returns all repetitions of Patient Address (PID-11). 611 */ 612 public XAD[] getPid11_PatientAddress() { 613 XAD[] retVal = this.getTypedField(11, new XAD[0]); 614 return retVal; 615 } 616 617 618 /** 619 * Returns a count of the current number of repetitions of Patient Address (PID-11). 620 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 621 * it will return zero. 622 */ 623 public int getPatientAddressReps() { 624 return this.getReps(11); 625 } 626 627 628 /** 629 * Returns a specific repetition of 630 * PID-11: "Patient Address" - creates it if necessary 631 * 632 * @param rep The repetition index (0-indexed) 633 */ 634 public XAD getPatientAddress(int rep) { 635 XAD retVal = this.getTypedField(11, rep); 636 return retVal; 637 } 638 639 /** 640 * Returns a specific repetition of 641 * PID-11: "Patient Address" - creates it if necessary 642 * 643 * @param rep The repetition index (0-indexed) 644 */ 645 public XAD getPid11_PatientAddress(int rep) { 646 XAD retVal = this.getTypedField(11, rep); 647 return retVal; 648 } 649 650 /** 651 * Returns a count of the current number of repetitions of Patient Address (PID-11). 652 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 653 * it will return zero. 654 */ 655 public int getPid11_PatientAddressReps() { 656 return this.getReps(11); 657 } 658 659 660 /** 661 * Inserts a repetition of 662 * PID-11: "Patient Address" at a specific index 663 * 664 * @param rep The repetition index (0-indexed) 665 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 666 */ 667 public XAD insertPatientAddress(int rep) throws HL7Exception { 668 return (XAD) super.insertRepetition(11, rep); 669 } 670 671 672 /** 673 * Inserts a repetition of 674 * PID-11: "Patient Address" at a specific index 675 * 676 * @param rep The repetition index (0-indexed) 677 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 678 */ 679 public XAD insertPid11_PatientAddress(int rep) throws HL7Exception { 680 return (XAD) super.insertRepetition(11, rep); 681 } 682 683 684 /** 685 * Removes a repetition of 686 * PID-11: "Patient Address" at a specific index 687 * 688 * @param rep The repetition index (0-indexed) 689 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 690 */ 691 public XAD removePatientAddress(int rep) throws HL7Exception { 692 return (XAD) super.removeRepetition(11, rep); 693 } 694 695 696 /** 697 * Removes a repetition of 698 * PID-11: "Patient Address" at a specific index 699 * 700 * @param rep The repetition index (0-indexed) 701 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 702 */ 703 public XAD removePid11_PatientAddress(int rep) throws HL7Exception { 704 return (XAD) super.removeRepetition(11, rep); 705 } 706 707 708 709 710 /** 711 * Returns 712 * PID-12: "County Code" - creates it if necessary 713 */ 714 public IS getCountyCode() { 715 IS retVal = this.getTypedField(12, 0); 716 return retVal; 717 } 718 719 /** 720 * Returns 721 * PID-12: "County Code" - creates it if necessary 722 */ 723 public IS getPid12_CountyCode() { 724 IS retVal = this.getTypedField(12, 0); 725 return retVal; 726 } 727 728 729 /** 730 * Returns all repetitions of Phone Number - Home (PID-13). 731 */ 732 public XTN[] getPhoneNumberHome() { 733 XTN[] retVal = this.getTypedField(13, new XTN[0]); 734 return retVal; 735 } 736 737 738 /** 739 * Returns all repetitions of Phone Number - Home (PID-13). 740 */ 741 public XTN[] getPid13_PhoneNumberHome() { 742 XTN[] retVal = this.getTypedField(13, new XTN[0]); 743 return retVal; 744 } 745 746 747 /** 748 * Returns a count of the current number of repetitions of Phone Number - Home (PID-13). 749 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 750 * it will return zero. 751 */ 752 public int getPhoneNumberHomeReps() { 753 return this.getReps(13); 754 } 755 756 757 /** 758 * Returns a specific repetition of 759 * PID-13: "Phone Number - Home" - creates it if necessary 760 * 761 * @param rep The repetition index (0-indexed) 762 */ 763 public XTN getPhoneNumberHome(int rep) { 764 XTN retVal = this.getTypedField(13, rep); 765 return retVal; 766 } 767 768 /** 769 * Returns a specific repetition of 770 * PID-13: "Phone Number - Home" - creates it if necessary 771 * 772 * @param rep The repetition index (0-indexed) 773 */ 774 public XTN getPid13_PhoneNumberHome(int rep) { 775 XTN retVal = this.getTypedField(13, rep); 776 return retVal; 777 } 778 779 /** 780 * Returns a count of the current number of repetitions of Phone Number - Home (PID-13). 781 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 782 * it will return zero. 783 */ 784 public int getPid13_PhoneNumberHomeReps() { 785 return this.getReps(13); 786 } 787 788 789 /** 790 * Inserts a repetition of 791 * PID-13: "Phone Number - Home" at a specific index 792 * 793 * @param rep The repetition index (0-indexed) 794 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 795 */ 796 public XTN insertPhoneNumberHome(int rep) throws HL7Exception { 797 return (XTN) super.insertRepetition(13, rep); 798 } 799 800 801 /** 802 * Inserts a repetition of 803 * PID-13: "Phone Number - Home" at a specific index 804 * 805 * @param rep The repetition index (0-indexed) 806 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 807 */ 808 public XTN insertPid13_PhoneNumberHome(int rep) throws HL7Exception { 809 return (XTN) super.insertRepetition(13, rep); 810 } 811 812 813 /** 814 * Removes a repetition of 815 * PID-13: "Phone Number - Home" at a specific index 816 * 817 * @param rep The repetition index (0-indexed) 818 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 819 */ 820 public XTN removePhoneNumberHome(int rep) throws HL7Exception { 821 return (XTN) super.removeRepetition(13, rep); 822 } 823 824 825 /** 826 * Removes a repetition of 827 * PID-13: "Phone Number - Home" at a specific index 828 * 829 * @param rep The repetition index (0-indexed) 830 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 831 */ 832 public XTN removePid13_PhoneNumberHome(int rep) throws HL7Exception { 833 return (XTN) super.removeRepetition(13, rep); 834 } 835 836 837 838 /** 839 * Returns all repetitions of Phone Number - Business (PID-14). 840 */ 841 public XTN[] getPhoneNumberBusiness() { 842 XTN[] retVal = this.getTypedField(14, new XTN[0]); 843 return retVal; 844 } 845 846 847 /** 848 * Returns all repetitions of Phone Number - Business (PID-14). 849 */ 850 public XTN[] getPid14_PhoneNumberBusiness() { 851 XTN[] retVal = this.getTypedField(14, new XTN[0]); 852 return retVal; 853 } 854 855 856 /** 857 * Returns a count of the current number of repetitions of Phone Number - Business (PID-14). 858 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 859 * it will return zero. 860 */ 861 public int getPhoneNumberBusinessReps() { 862 return this.getReps(14); 863 } 864 865 866 /** 867 * Returns a specific repetition of 868 * PID-14: "Phone Number - Business" - creates it if necessary 869 * 870 * @param rep The repetition index (0-indexed) 871 */ 872 public XTN getPhoneNumberBusiness(int rep) { 873 XTN retVal = this.getTypedField(14, rep); 874 return retVal; 875 } 876 877 /** 878 * Returns a specific repetition of 879 * PID-14: "Phone Number - Business" - creates it if necessary 880 * 881 * @param rep The repetition index (0-indexed) 882 */ 883 public XTN getPid14_PhoneNumberBusiness(int rep) { 884 XTN retVal = this.getTypedField(14, rep); 885 return retVal; 886 } 887 888 /** 889 * Returns a count of the current number of repetitions of Phone Number - Business (PID-14). 890 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 891 * it will return zero. 892 */ 893 public int getPid14_PhoneNumberBusinessReps() { 894 return this.getReps(14); 895 } 896 897 898 /** 899 * Inserts a repetition of 900 * PID-14: "Phone Number - Business" at a specific index 901 * 902 * @param rep The repetition index (0-indexed) 903 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 904 */ 905 public XTN insertPhoneNumberBusiness(int rep) throws HL7Exception { 906 return (XTN) super.insertRepetition(14, rep); 907 } 908 909 910 /** 911 * Inserts a repetition of 912 * PID-14: "Phone Number - Business" at a specific index 913 * 914 * @param rep The repetition index (0-indexed) 915 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 916 */ 917 public XTN insertPid14_PhoneNumberBusiness(int rep) throws HL7Exception { 918 return (XTN) super.insertRepetition(14, rep); 919 } 920 921 922 /** 923 * Removes a repetition of 924 * PID-14: "Phone Number - Business" at a specific index 925 * 926 * @param rep The repetition index (0-indexed) 927 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 928 */ 929 public XTN removePhoneNumberBusiness(int rep) throws HL7Exception { 930 return (XTN) super.removeRepetition(14, rep); 931 } 932 933 934 /** 935 * Removes a repetition of 936 * PID-14: "Phone Number - Business" at a specific index 937 * 938 * @param rep The repetition index (0-indexed) 939 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 940 */ 941 public XTN removePid14_PhoneNumberBusiness(int rep) throws HL7Exception { 942 return (XTN) super.removeRepetition(14, rep); 943 } 944 945 946 947 948 /** 949 * Returns 950 * PID-15: "Primary Language" - creates it if necessary 951 */ 952 public CE getPrimaryLanguage() { 953 CE retVal = this.getTypedField(15, 0); 954 return retVal; 955 } 956 957 /** 958 * Returns 959 * PID-15: "Primary Language" - creates it if necessary 960 */ 961 public CE getPid15_PrimaryLanguage() { 962 CE retVal = this.getTypedField(15, 0); 963 return retVal; 964 } 965 966 967 /** 968 * Returns all repetitions of Marital Status (PID-16). 969 */ 970 public IS[] getMaritalStatus() { 971 IS[] retVal = this.getTypedField(16, new IS[0]); 972 return retVal; 973 } 974 975 976 /** 977 * Returns all repetitions of Marital Status (PID-16). 978 */ 979 public IS[] getPid16_MaritalStatus() { 980 IS[] retVal = this.getTypedField(16, new IS[0]); 981 return retVal; 982 } 983 984 985 /** 986 * Returns a count of the current number of repetitions of Marital Status (PID-16). 987 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 988 * it will return zero. 989 */ 990 public int getMaritalStatusReps() { 991 return this.getReps(16); 992 } 993 994 995 /** 996 * Returns a specific repetition of 997 * PID-16: "Marital Status" - creates it if necessary 998 * 999 * @param rep The repetition index (0-indexed) 1000 */ 1001 public IS getMaritalStatus(int rep) { 1002 IS retVal = this.getTypedField(16, rep); 1003 return retVal; 1004 } 1005 1006 /** 1007 * Returns a specific repetition of 1008 * PID-16: "Marital Status" - creates it if necessary 1009 * 1010 * @param rep The repetition index (0-indexed) 1011 */ 1012 public IS getPid16_MaritalStatus(int rep) { 1013 IS retVal = this.getTypedField(16, rep); 1014 return retVal; 1015 } 1016 1017 /** 1018 * Returns a count of the current number of repetitions of Marital Status (PID-16). 1019 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1020 * it will return zero. 1021 */ 1022 public int getPid16_MaritalStatusReps() { 1023 return this.getReps(16); 1024 } 1025 1026 1027 /** 1028 * Inserts a repetition of 1029 * PID-16: "Marital Status" at a specific index 1030 * 1031 * @param rep The repetition index (0-indexed) 1032 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1033 */ 1034 public IS insertMaritalStatus(int rep) throws HL7Exception { 1035 return (IS) super.insertRepetition(16, rep); 1036 } 1037 1038 1039 /** 1040 * Inserts a repetition of 1041 * PID-16: "Marital Status" at a specific index 1042 * 1043 * @param rep The repetition index (0-indexed) 1044 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1045 */ 1046 public IS insertPid16_MaritalStatus(int rep) throws HL7Exception { 1047 return (IS) super.insertRepetition(16, rep); 1048 } 1049 1050 1051 /** 1052 * Removes a repetition of 1053 * PID-16: "Marital Status" at a specific index 1054 * 1055 * @param rep The repetition index (0-indexed) 1056 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1057 */ 1058 public IS removeMaritalStatus(int rep) throws HL7Exception { 1059 return (IS) super.removeRepetition(16, rep); 1060 } 1061 1062 1063 /** 1064 * Removes a repetition of 1065 * PID-16: "Marital Status" at a specific index 1066 * 1067 * @param rep The repetition index (0-indexed) 1068 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1069 */ 1070 public IS removePid16_MaritalStatus(int rep) throws HL7Exception { 1071 return (IS) super.removeRepetition(16, rep); 1072 } 1073 1074 1075 1076 1077 /** 1078 * Returns 1079 * PID-17: "Religion" - creates it if necessary 1080 */ 1081 public IS getReligion() { 1082 IS retVal = this.getTypedField(17, 0); 1083 return retVal; 1084 } 1085 1086 /** 1087 * Returns 1088 * PID-17: "Religion" - creates it if necessary 1089 */ 1090 public IS getPid17_Religion() { 1091 IS retVal = this.getTypedField(17, 0); 1092 return retVal; 1093 } 1094 1095 1096 1097 /** 1098 * Returns 1099 * PID-18: "Patient Account Number" - creates it if necessary 1100 */ 1101 public CX getPatientAccountNumber() { 1102 CX retVal = this.getTypedField(18, 0); 1103 return retVal; 1104 } 1105 1106 /** 1107 * Returns 1108 * PID-18: "Patient Account Number" - creates it if necessary 1109 */ 1110 public CX getPid18_PatientAccountNumber() { 1111 CX retVal = this.getTypedField(18, 0); 1112 return retVal; 1113 } 1114 1115 1116 1117 /** 1118 * Returns 1119 * PID-19: "SSN Number - Patient" - creates it if necessary 1120 */ 1121 public ST getSSNNumberPatient() { 1122 ST retVal = this.getTypedField(19, 0); 1123 return retVal; 1124 } 1125 1126 /** 1127 * Returns 1128 * PID-19: "SSN Number - Patient" - creates it if necessary 1129 */ 1130 public ST getPid19_SSNNumberPatient() { 1131 ST retVal = this.getTypedField(19, 0); 1132 return retVal; 1133 } 1134 1135 1136 1137 /** 1138 * Returns 1139 * PID-20: "Driver's License Number" - creates it if necessary 1140 */ 1141 public DLN getDriverSLicenseNumber() { 1142 DLN retVal = this.getTypedField(20, 0); 1143 return retVal; 1144 } 1145 1146 /** 1147 * Returns 1148 * PID-20: "Driver's License Number" - creates it if necessary 1149 */ 1150 public DLN getPid20_DriverSLicenseNumber() { 1151 DLN retVal = this.getTypedField(20, 0); 1152 return retVal; 1153 } 1154 1155 1156 1157 /** 1158 * Returns 1159 * PID-21: "Mother's Identifier" - creates it if necessary 1160 */ 1161 public CX getMotherSIdentifier() { 1162 CX retVal = this.getTypedField(21, 0); 1163 return retVal; 1164 } 1165 1166 /** 1167 * Returns 1168 * PID-21: "Mother's Identifier" - creates it if necessary 1169 */ 1170 public CX getPid21_MotherSIdentifier() { 1171 CX retVal = this.getTypedField(21, 0); 1172 return retVal; 1173 } 1174 1175 1176 1177 /** 1178 * Returns 1179 * PID-22: "Ethnic Group" - creates it if necessary 1180 */ 1181 public IS getEthnicGroup() { 1182 IS retVal = this.getTypedField(22, 0); 1183 return retVal; 1184 } 1185 1186 /** 1187 * Returns 1188 * PID-22: "Ethnic Group" - creates it if necessary 1189 */ 1190 public IS getPid22_EthnicGroup() { 1191 IS retVal = this.getTypedField(22, 0); 1192 return retVal; 1193 } 1194 1195 1196 1197 /** 1198 * Returns 1199 * PID-23: "Birth Place" - creates it if necessary 1200 */ 1201 public ST getBirthPlace() { 1202 ST retVal = this.getTypedField(23, 0); 1203 return retVal; 1204 } 1205 1206 /** 1207 * Returns 1208 * PID-23: "Birth Place" - creates it if necessary 1209 */ 1210 public ST getPid23_BirthPlace() { 1211 ST retVal = this.getTypedField(23, 0); 1212 return retVal; 1213 } 1214 1215 1216 1217 /** 1218 * Returns 1219 * PID-24: "Multiple Birth Indicator" - creates it if necessary 1220 */ 1221 public ID getMultipleBirthIndicator() { 1222 ID retVal = this.getTypedField(24, 0); 1223 return retVal; 1224 } 1225 1226 /** 1227 * Returns 1228 * PID-24: "Multiple Birth Indicator" - creates it if necessary 1229 */ 1230 public ID getPid24_MultipleBirthIndicator() { 1231 ID retVal = this.getTypedField(24, 0); 1232 return retVal; 1233 } 1234 1235 1236 1237 /** 1238 * Returns 1239 * PID-25: "Birth Order" - creates it if necessary 1240 */ 1241 public NM getBirthOrder() { 1242 NM retVal = this.getTypedField(25, 0); 1243 return retVal; 1244 } 1245 1246 /** 1247 * Returns 1248 * PID-25: "Birth Order" - creates it if necessary 1249 */ 1250 public NM getPid25_BirthOrder() { 1251 NM retVal = this.getTypedField(25, 0); 1252 return retVal; 1253 } 1254 1255 1256 1257 /** 1258 * Returns 1259 * PID-26: "Citizenship" - creates it if necessary 1260 */ 1261 public IS getCitizenship() { 1262 IS retVal = this.getTypedField(26, 0); 1263 return retVal; 1264 } 1265 1266 /** 1267 * Returns 1268 * PID-26: "Citizenship" - creates it if necessary 1269 */ 1270 public IS getPid26_Citizenship() { 1271 IS retVal = this.getTypedField(26, 0); 1272 return retVal; 1273 } 1274 1275 1276 1277 /** 1278 * Returns 1279 * PID-27: "Veterans Military Status" - creates it if necessary 1280 */ 1281 public CE getVeteransMilitaryStatus() { 1282 CE retVal = this.getTypedField(27, 0); 1283 return retVal; 1284 } 1285 1286 /** 1287 * Returns 1288 * PID-27: "Veterans Military Status" - creates it if necessary 1289 */ 1290 public CE getPid27_VeteransMilitaryStatus() { 1291 CE retVal = this.getTypedField(27, 0); 1292 return retVal; 1293 } 1294 1295 1296 1297 /** 1298 * Returns 1299 * PID-28: "Nationality Code" - creates it if necessary 1300 */ 1301 public CE getNationalityCode() { 1302 CE retVal = this.getTypedField(28, 0); 1303 return retVal; 1304 } 1305 1306 /** 1307 * Returns 1308 * PID-28: "Nationality Code" - creates it if necessary 1309 */ 1310 public CE getPid28_NationalityCode() { 1311 CE retVal = this.getTypedField(28, 0); 1312 return retVal; 1313 } 1314 1315 1316 1317 /** 1318 * Returns 1319 * PID-29: "Patient Death Date and Time" - creates it if necessary 1320 */ 1321 public TS getPatientDeathDateAndTime() { 1322 TS retVal = this.getTypedField(29, 0); 1323 return retVal; 1324 } 1325 1326 /** 1327 * Returns 1328 * PID-29: "Patient Death Date and Time" - creates it if necessary 1329 */ 1330 public TS getPid29_PatientDeathDateAndTime() { 1331 TS retVal = this.getTypedField(29, 0); 1332 return retVal; 1333 } 1334 1335 1336 1337 /** 1338 * Returns 1339 * PID-30: "Patient Death Indicator" - creates it if necessary 1340 */ 1341 public ID getPatientDeathIndicator() { 1342 ID retVal = this.getTypedField(30, 0); 1343 return retVal; 1344 } 1345 1346 /** 1347 * Returns 1348 * PID-30: "Patient Death Indicator" - creates it if necessary 1349 */ 1350 public ID getPid30_PatientDeathIndicator() { 1351 ID retVal = this.getTypedField(30, 0); 1352 return retVal; 1353 } 1354 1355 1356 1357 1358 1359 /** {@inheritDoc} */ 1360 protected Type createNewTypeWithoutReflection(int field) { 1361 switch (field) { 1362 case 0: return new SI(getMessage()); 1363 case 1: return new CX(getMessage()); 1364 case 2: return new CX(getMessage()); 1365 case 3: return new CX(getMessage()); 1366 case 4: return new XPN(getMessage()); 1367 case 5: return new XPN(getMessage()); 1368 case 6: return new TS(getMessage()); 1369 case 7: return new IS(getMessage(), new Integer( 1 )); 1370 case 8: return new XPN(getMessage()); 1371 case 9: return new IS(getMessage(), new Integer( 5 )); 1372 case 10: return new XAD(getMessage()); 1373 case 11: return new IS(getMessage(), new Integer( 0 )); 1374 case 12: return new XTN(getMessage()); 1375 case 13: return new XTN(getMessage()); 1376 case 14: return new CE(getMessage()); 1377 case 15: return new IS(getMessage(), new Integer( 2 )); 1378 case 16: return new IS(getMessage(), new Integer( 6 )); 1379 case 17: return new CX(getMessage()); 1380 case 18: return new ST(getMessage()); 1381 case 19: return new DLN(getMessage()); 1382 case 20: return new CX(getMessage()); 1383 case 21: return new IS(getMessage(), new Integer( 189 )); 1384 case 22: return new ST(getMessage()); 1385 case 23: return new ID(getMessage(), new Integer( 136 )); 1386 case 24: return new NM(getMessage()); 1387 case 25: return new IS(getMessage(), new Integer( 171 )); 1388 case 26: return new CE(getMessage()); 1389 case 27: return new CE(getMessage()); 1390 case 28: return new TS(getMessage()); 1391 case 29: return new ID(getMessage(), new Integer( 136 )); 1392 default: return null; 1393 } 1394 } 1395 1396 1397} 1398