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