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