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.v231.segment; 035 036// import ca.uhn.hl7v2.model.v231.group.*; 037import ca.uhn.hl7v2.model.v231.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 STF message segment (STF - staff identification segment). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>STF-1: Primary Key Value - STF (CE) <b> </b> 053 * <li>STF-2: Staff ID Code (CX) <b>optional repeating</b> 054 * <li>STF-3: Staff Name (XPN) <b>optional repeating</b> 055 * <li>STF-4: Staff Type (IS) <b>optional repeating</b> 056 * <li>STF-5: Sex (IS) <b>optional </b> 057 * <li>STF-6: Date/Time Of Birth (TS) <b>optional </b> 058 * <li>STF-7: Active/Inactive Flag (ID) <b>optional </b> 059 * <li>STF-8: Department (CE) <b>optional repeating</b> 060 * <li>STF-9: Hospital Service (CE) <b>optional repeating</b> 061 * <li>STF-10: Phone (XTN) <b>optional repeating</b> 062 * <li>STF-11: Office/Home Address (XAD) <b>optional repeating</b> 063 * <li>STF-12: Institution Activation Date (DIN) <b>optional repeating</b> 064 * <li>STF-13: Institution Inactivation Date (DIN) <b>optional repeating</b> 065 * <li>STF-14: Backup Person ID (CE) <b>optional repeating</b> 066 * <li>STF-15: E-Mail Address (ST) <b>optional repeating</b> 067 * <li>STF-16: Preferred Method Of Contact (CE) <b>optional </b> 068 * <li>STF-17: Marital Status (CE) <b>optional </b> 069 * <li>STF-18: Job Title (ST) <b>optional </b> 070 * <li>STF-19: Job Code/Class (JCC) <b>optional </b> 071 * <li>STF-20: Employment Status (IS) <b>optional </b> 072 * <li>STF-21: Additional Insured on Auto (ID) <b>optional </b> 073 * <li>STF-22: Driver’s License Number - Staff (DLN) <b>optional </b> 074 * <li>STF-23: Copy Auto Ins (ID) <b>optional </b> 075 * <li>STF-24: Auto Ins. Expires (DT) <b>optional </b> 076 * <li>STF-25: Date Last DMV Review (DT) <b>optional </b> 077 * <li>STF-26: Date Next DMV Review (DT) <b>optional </b> 078 * </ul> 079 */ 080@SuppressWarnings("unused") 081public class STF extends AbstractSegment { 082 083 /** 084 * Creates a new STF segment 085 */ 086 public STF(Group parent, ModelClassFactory factory) { 087 super(parent, factory); 088 init(factory); 089 } 090 091 private void init(ModelClassFactory factory) { 092 try { 093 this.add(CE.class, true, 1, 60, new Object[]{ getMessage() }, "Primary Key Value - STF"); 094 this.add(CX.class, false, 0, 60, new Object[]{ getMessage() }, "Staff ID Code"); 095 this.add(XPN.class, false, 0, 48, new Object[]{ getMessage() }, "Staff Name"); 096 this.add(IS.class, false, 0, 2, new Object[]{ getMessage(), new Integer(182) }, "Staff Type"); 097 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Sex"); 098 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time Of Birth"); 099 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(183) }, "Active/Inactive Flag"); 100 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Department"); 101 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Hospital Service"); 102 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone"); 103 this.add(XAD.class, false, 0, 106, new Object[]{ getMessage() }, "Office/Home Address"); 104 this.add(DIN.class, false, 0, 26, new Object[]{ getMessage() }, "Institution Activation Date"); 105 this.add(DIN.class, false, 0, 26, new Object[]{ getMessage() }, "Institution Inactivation Date"); 106 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Backup Person ID"); 107 this.add(ST.class, false, 0, 40, new Object[]{ getMessage() }, "E-Mail Address"); 108 this.add(CE.class, false, 1, 200, new Object[]{ getMessage() }, "Preferred Method Of Contact"); 109 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Marital Status"); 110 this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Job Title"); 111 this.add(JCC.class, false, 1, 20, new Object[]{ getMessage() }, "Job Code/Class"); 112 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(66) }, "Employment Status"); 113 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Additional Insured on Auto"); 114 this.add(DLN.class, false, 1, 25, new Object[]{ getMessage() }, "Driver’s License Number - Staff"); 115 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Copy Auto Ins"); 116 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Auto Ins. Expires"); 117 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Date Last DMV Review"); 118 this.add(DT.class, false, 1, 8, new Object[]{ getMessage() }, "Date Next DMV Review"); 119 } catch(HL7Exception e) { 120 log.error("Unexpected error creating STF - this is probably a bug in the source code generator.", e); 121 } 122 } 123 124 125 126 /** 127 * Returns 128 * STF-1: "Primary Key Value - STF" - creates it if necessary 129 */ 130 public CE getPrimaryKeyValueSTF() { 131 CE retVal = this.getTypedField(1, 0); 132 return retVal; 133 } 134 135 /** 136 * Returns 137 * STF-1: "Primary Key Value - STF" - creates it if necessary 138 */ 139 public CE getStf1_PrimaryKeyValueSTF() { 140 CE retVal = this.getTypedField(1, 0); 141 return retVal; 142 } 143 144 145 /** 146 * Returns all repetitions of Staff ID Code (STF-2). 147 */ 148 public CX[] getStaffIDCode() { 149 CX[] retVal = this.getTypedField(2, new CX[0]); 150 return retVal; 151 } 152 153 154 /** 155 * Returns all repetitions of Staff ID Code (STF-2). 156 */ 157 public CX[] getStf2_StaffIDCode() { 158 CX[] retVal = this.getTypedField(2, new CX[0]); 159 return retVal; 160 } 161 162 163 /** 164 * Returns a count of the current number of repetitions of Staff ID Code (STF-2). 165 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 166 * it will return zero. 167 */ 168 public int getStaffIDCodeReps() { 169 return this.getReps(2); 170 } 171 172 173 /** 174 * Returns a specific repetition of 175 * STF-2: "Staff ID Code" - creates it if necessary 176 * 177 * @param rep The repetition index (0-indexed) 178 */ 179 public CX getStaffIDCode(int rep) { 180 CX retVal = this.getTypedField(2, rep); 181 return retVal; 182 } 183 184 /** 185 * Returns a specific repetition of 186 * STF-2: "Staff ID Code" - creates it if necessary 187 * 188 * @param rep The repetition index (0-indexed) 189 */ 190 public CX getStf2_StaffIDCode(int rep) { 191 CX retVal = this.getTypedField(2, rep); 192 return retVal; 193 } 194 195 /** 196 * Returns a count of the current number of repetitions of Staff ID Code (STF-2). 197 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 198 * it will return zero. 199 */ 200 public int getStf2_StaffIDCodeReps() { 201 return this.getReps(2); 202 } 203 204 205 /** 206 * Inserts a repetition of 207 * STF-2: "Staff ID Code" at a specific index 208 * 209 * @param rep The repetition index (0-indexed) 210 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 211 */ 212 public CX insertStaffIDCode(int rep) throws HL7Exception { 213 return (CX) super.insertRepetition(2, rep); 214 } 215 216 217 /** 218 * Inserts a repetition of 219 * STF-2: "Staff ID Code" at a specific index 220 * 221 * @param rep The repetition index (0-indexed) 222 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 223 */ 224 public CX insertStf2_StaffIDCode(int rep) throws HL7Exception { 225 return (CX) super.insertRepetition(2, rep); 226 } 227 228 229 /** 230 * Removes a repetition of 231 * STF-2: "Staff ID Code" at a specific index 232 * 233 * @param rep The repetition index (0-indexed) 234 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 235 */ 236 public CX removeStaffIDCode(int rep) throws HL7Exception { 237 return (CX) super.removeRepetition(2, rep); 238 } 239 240 241 /** 242 * Removes a repetition of 243 * STF-2: "Staff ID Code" at a specific index 244 * 245 * @param rep The repetition index (0-indexed) 246 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 247 */ 248 public CX removeStf2_StaffIDCode(int rep) throws HL7Exception { 249 return (CX) super.removeRepetition(2, rep); 250 } 251 252 253 254 /** 255 * Returns all repetitions of Staff Name (STF-3). 256 */ 257 public XPN[] getStaffName() { 258 XPN[] retVal = this.getTypedField(3, new XPN[0]); 259 return retVal; 260 } 261 262 263 /** 264 * Returns all repetitions of Staff Name (STF-3). 265 */ 266 public XPN[] getStf3_StaffName() { 267 XPN[] retVal = this.getTypedField(3, new XPN[0]); 268 return retVal; 269 } 270 271 272 /** 273 * Returns a count of the current number of repetitions of Staff Name (STF-3). 274 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 275 * it will return zero. 276 */ 277 public int getStaffNameReps() { 278 return this.getReps(3); 279 } 280 281 282 /** 283 * Returns a specific repetition of 284 * STF-3: "Staff Name" - creates it if necessary 285 * 286 * @param rep The repetition index (0-indexed) 287 */ 288 public XPN getStaffName(int rep) { 289 XPN retVal = this.getTypedField(3, rep); 290 return retVal; 291 } 292 293 /** 294 * Returns a specific repetition of 295 * STF-3: "Staff Name" - creates it if necessary 296 * 297 * @param rep The repetition index (0-indexed) 298 */ 299 public XPN getStf3_StaffName(int rep) { 300 XPN retVal = this.getTypedField(3, rep); 301 return retVal; 302 } 303 304 /** 305 * Returns a count of the current number of repetitions of Staff Name (STF-3). 306 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 307 * it will return zero. 308 */ 309 public int getStf3_StaffNameReps() { 310 return this.getReps(3); 311 } 312 313 314 /** 315 * Inserts a repetition of 316 * STF-3: "Staff Name" at a specific index 317 * 318 * @param rep The repetition index (0-indexed) 319 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 320 */ 321 public XPN insertStaffName(int rep) throws HL7Exception { 322 return (XPN) super.insertRepetition(3, rep); 323 } 324 325 326 /** 327 * Inserts a repetition of 328 * STF-3: "Staff Name" at a specific index 329 * 330 * @param rep The repetition index (0-indexed) 331 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 332 */ 333 public XPN insertStf3_StaffName(int rep) throws HL7Exception { 334 return (XPN) super.insertRepetition(3, rep); 335 } 336 337 338 /** 339 * Removes a repetition of 340 * STF-3: "Staff Name" at a specific index 341 * 342 * @param rep The repetition index (0-indexed) 343 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 344 */ 345 public XPN removeStaffName(int rep) throws HL7Exception { 346 return (XPN) super.removeRepetition(3, rep); 347 } 348 349 350 /** 351 * Removes a repetition of 352 * STF-3: "Staff Name" at a specific index 353 * 354 * @param rep The repetition index (0-indexed) 355 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 356 */ 357 public XPN removeStf3_StaffName(int rep) throws HL7Exception { 358 return (XPN) super.removeRepetition(3, rep); 359 } 360 361 362 363 /** 364 * Returns all repetitions of Staff Type (STF-4). 365 */ 366 public IS[] getStaffType() { 367 IS[] retVal = this.getTypedField(4, new IS[0]); 368 return retVal; 369 } 370 371 372 /** 373 * Returns all repetitions of Staff Type (STF-4). 374 */ 375 public IS[] getStf4_StaffType() { 376 IS[] retVal = this.getTypedField(4, new IS[0]); 377 return retVal; 378 } 379 380 381 /** 382 * Returns a count of the current number of repetitions of Staff Type (STF-4). 383 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 384 * it will return zero. 385 */ 386 public int getStaffTypeReps() { 387 return this.getReps(4); 388 } 389 390 391 /** 392 * Returns a specific repetition of 393 * STF-4: "Staff Type" - creates it if necessary 394 * 395 * @param rep The repetition index (0-indexed) 396 */ 397 public IS getStaffType(int rep) { 398 IS retVal = this.getTypedField(4, rep); 399 return retVal; 400 } 401 402 /** 403 * Returns a specific repetition of 404 * STF-4: "Staff Type" - creates it if necessary 405 * 406 * @param rep The repetition index (0-indexed) 407 */ 408 public IS getStf4_StaffType(int rep) { 409 IS retVal = this.getTypedField(4, rep); 410 return retVal; 411 } 412 413 /** 414 * Returns a count of the current number of repetitions of Staff Type (STF-4). 415 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 416 * it will return zero. 417 */ 418 public int getStf4_StaffTypeReps() { 419 return this.getReps(4); 420 } 421 422 423 /** 424 * Inserts a repetition of 425 * STF-4: "Staff Type" at a specific index 426 * 427 * @param rep The repetition index (0-indexed) 428 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 429 */ 430 public IS insertStaffType(int rep) throws HL7Exception { 431 return (IS) super.insertRepetition(4, rep); 432 } 433 434 435 /** 436 * Inserts a repetition of 437 * STF-4: "Staff Type" at a specific index 438 * 439 * @param rep The repetition index (0-indexed) 440 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 441 */ 442 public IS insertStf4_StaffType(int rep) throws HL7Exception { 443 return (IS) super.insertRepetition(4, rep); 444 } 445 446 447 /** 448 * Removes a repetition of 449 * STF-4: "Staff Type" at a specific index 450 * 451 * @param rep The repetition index (0-indexed) 452 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 453 */ 454 public IS removeStaffType(int rep) throws HL7Exception { 455 return (IS) super.removeRepetition(4, rep); 456 } 457 458 459 /** 460 * Removes a repetition of 461 * STF-4: "Staff Type" at a specific index 462 * 463 * @param rep The repetition index (0-indexed) 464 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 465 */ 466 public IS removeStf4_StaffType(int rep) throws HL7Exception { 467 return (IS) super.removeRepetition(4, rep); 468 } 469 470 471 472 473 /** 474 * Returns 475 * STF-5: "Sex" - creates it if necessary 476 */ 477 public IS getSex() { 478 IS retVal = this.getTypedField(5, 0); 479 return retVal; 480 } 481 482 /** 483 * Returns 484 * STF-5: "Sex" - creates it if necessary 485 */ 486 public IS getStf5_Sex() { 487 IS retVal = this.getTypedField(5, 0); 488 return retVal; 489 } 490 491 492 493 /** 494 * Returns 495 * STF-6: "Date/Time Of Birth" - creates it if necessary 496 */ 497 public TS getDateTimeOfBirth() { 498 TS retVal = this.getTypedField(6, 0); 499 return retVal; 500 } 501 502 /** 503 * Returns 504 * STF-6: "Date/Time Of Birth" - creates it if necessary 505 */ 506 public TS getStf6_DateTimeOfBirth() { 507 TS retVal = this.getTypedField(6, 0); 508 return retVal; 509 } 510 511 512 513 /** 514 * Returns 515 * STF-7: "Active/Inactive Flag" - creates it if necessary 516 */ 517 public ID getActiveInactiveFlag() { 518 ID retVal = this.getTypedField(7, 0); 519 return retVal; 520 } 521 522 /** 523 * Returns 524 * STF-7: "Active/Inactive Flag" - creates it if necessary 525 */ 526 public ID getStf7_ActiveInactiveFlag() { 527 ID retVal = this.getTypedField(7, 0); 528 return retVal; 529 } 530 531 532 /** 533 * Returns all repetitions of Department (STF-8). 534 */ 535 public CE[] getDepartment() { 536 CE[] retVal = this.getTypedField(8, new CE[0]); 537 return retVal; 538 } 539 540 541 /** 542 * Returns all repetitions of Department (STF-8). 543 */ 544 public CE[] getStf8_Department() { 545 CE[] retVal = this.getTypedField(8, new CE[0]); 546 return retVal; 547 } 548 549 550 /** 551 * Returns a count of the current number of repetitions of Department (STF-8). 552 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 553 * it will return zero. 554 */ 555 public int getDepartmentReps() { 556 return this.getReps(8); 557 } 558 559 560 /** 561 * Returns a specific repetition of 562 * STF-8: "Department" - creates it if necessary 563 * 564 * @param rep The repetition index (0-indexed) 565 */ 566 public CE getDepartment(int rep) { 567 CE retVal = this.getTypedField(8, rep); 568 return retVal; 569 } 570 571 /** 572 * Returns a specific repetition of 573 * STF-8: "Department" - creates it if necessary 574 * 575 * @param rep The repetition index (0-indexed) 576 */ 577 public CE getStf8_Department(int rep) { 578 CE retVal = this.getTypedField(8, rep); 579 return retVal; 580 } 581 582 /** 583 * Returns a count of the current number of repetitions of Department (STF-8). 584 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 585 * it will return zero. 586 */ 587 public int getStf8_DepartmentReps() { 588 return this.getReps(8); 589 } 590 591 592 /** 593 * Inserts a repetition of 594 * STF-8: "Department" at a specific index 595 * 596 * @param rep The repetition index (0-indexed) 597 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 598 */ 599 public CE insertDepartment(int rep) throws HL7Exception { 600 return (CE) super.insertRepetition(8, rep); 601 } 602 603 604 /** 605 * Inserts a repetition of 606 * STF-8: "Department" at a specific index 607 * 608 * @param rep The repetition index (0-indexed) 609 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 610 */ 611 public CE insertStf8_Department(int rep) throws HL7Exception { 612 return (CE) super.insertRepetition(8, rep); 613 } 614 615 616 /** 617 * Removes a repetition of 618 * STF-8: "Department" at a specific index 619 * 620 * @param rep The repetition index (0-indexed) 621 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 622 */ 623 public CE removeDepartment(int rep) throws HL7Exception { 624 return (CE) super.removeRepetition(8, rep); 625 } 626 627 628 /** 629 * Removes a repetition of 630 * STF-8: "Department" at a specific index 631 * 632 * @param rep The repetition index (0-indexed) 633 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 634 */ 635 public CE removeStf8_Department(int rep) throws HL7Exception { 636 return (CE) super.removeRepetition(8, rep); 637 } 638 639 640 641 /** 642 * Returns all repetitions of Hospital Service (STF-9). 643 */ 644 public CE[] getHospitalService() { 645 CE[] retVal = this.getTypedField(9, new CE[0]); 646 return retVal; 647 } 648 649 650 /** 651 * Returns all repetitions of Hospital Service (STF-9). 652 */ 653 public CE[] getStf9_HospitalService() { 654 CE[] retVal = this.getTypedField(9, new CE[0]); 655 return retVal; 656 } 657 658 659 /** 660 * Returns a count of the current number of repetitions of Hospital Service (STF-9). 661 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 662 * it will return zero. 663 */ 664 public int getHospitalServiceReps() { 665 return this.getReps(9); 666 } 667 668 669 /** 670 * Returns a specific repetition of 671 * STF-9: "Hospital Service" - creates it if necessary 672 * 673 * @param rep The repetition index (0-indexed) 674 */ 675 public CE getHospitalService(int rep) { 676 CE retVal = this.getTypedField(9, rep); 677 return retVal; 678 } 679 680 /** 681 * Returns a specific repetition of 682 * STF-9: "Hospital Service" - creates it if necessary 683 * 684 * @param rep The repetition index (0-indexed) 685 */ 686 public CE getStf9_HospitalService(int rep) { 687 CE retVal = this.getTypedField(9, rep); 688 return retVal; 689 } 690 691 /** 692 * Returns a count of the current number of repetitions of Hospital Service (STF-9). 693 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 694 * it will return zero. 695 */ 696 public int getStf9_HospitalServiceReps() { 697 return this.getReps(9); 698 } 699 700 701 /** 702 * Inserts a repetition of 703 * STF-9: "Hospital Service" at a specific index 704 * 705 * @param rep The repetition index (0-indexed) 706 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 707 */ 708 public CE insertHospitalService(int rep) throws HL7Exception { 709 return (CE) super.insertRepetition(9, rep); 710 } 711 712 713 /** 714 * Inserts a repetition of 715 * STF-9: "Hospital Service" at a specific index 716 * 717 * @param rep The repetition index (0-indexed) 718 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 719 */ 720 public CE insertStf9_HospitalService(int rep) throws HL7Exception { 721 return (CE) super.insertRepetition(9, rep); 722 } 723 724 725 /** 726 * Removes a repetition of 727 * STF-9: "Hospital Service" at a specific index 728 * 729 * @param rep The repetition index (0-indexed) 730 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 731 */ 732 public CE removeHospitalService(int rep) throws HL7Exception { 733 return (CE) super.removeRepetition(9, rep); 734 } 735 736 737 /** 738 * Removes a repetition of 739 * STF-9: "Hospital Service" at a specific index 740 * 741 * @param rep The repetition index (0-indexed) 742 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 743 */ 744 public CE removeStf9_HospitalService(int rep) throws HL7Exception { 745 return (CE) super.removeRepetition(9, rep); 746 } 747 748 749 750 /** 751 * Returns all repetitions of Phone (STF-10). 752 */ 753 public XTN[] getPhone() { 754 XTN[] retVal = this.getTypedField(10, new XTN[0]); 755 return retVal; 756 } 757 758 759 /** 760 * Returns all repetitions of Phone (STF-10). 761 */ 762 public XTN[] getStf10_Phone() { 763 XTN[] retVal = this.getTypedField(10, new XTN[0]); 764 return retVal; 765 } 766 767 768 /** 769 * Returns a count of the current number of repetitions of Phone (STF-10). 770 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 771 * it will return zero. 772 */ 773 public int getPhoneReps() { 774 return this.getReps(10); 775 } 776 777 778 /** 779 * Returns a specific repetition of 780 * STF-10: "Phone" - creates it if necessary 781 * 782 * @param rep The repetition index (0-indexed) 783 */ 784 public XTN getPhone(int rep) { 785 XTN retVal = this.getTypedField(10, rep); 786 return retVal; 787 } 788 789 /** 790 * Returns a specific repetition of 791 * STF-10: "Phone" - creates it if necessary 792 * 793 * @param rep The repetition index (0-indexed) 794 */ 795 public XTN getStf10_Phone(int rep) { 796 XTN retVal = this.getTypedField(10, rep); 797 return retVal; 798 } 799 800 /** 801 * Returns a count of the current number of repetitions of Phone (STF-10). 802 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 803 * it will return zero. 804 */ 805 public int getStf10_PhoneReps() { 806 return this.getReps(10); 807 } 808 809 810 /** 811 * Inserts a repetition of 812 * STF-10: "Phone" at a specific index 813 * 814 * @param rep The repetition index (0-indexed) 815 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 816 */ 817 public XTN insertPhone(int rep) throws HL7Exception { 818 return (XTN) super.insertRepetition(10, rep); 819 } 820 821 822 /** 823 * Inserts a repetition of 824 * STF-10: "Phone" at a specific index 825 * 826 * @param rep The repetition index (0-indexed) 827 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 828 */ 829 public XTN insertStf10_Phone(int rep) throws HL7Exception { 830 return (XTN) super.insertRepetition(10, rep); 831 } 832 833 834 /** 835 * Removes a repetition of 836 * STF-10: "Phone" at a specific index 837 * 838 * @param rep The repetition index (0-indexed) 839 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 840 */ 841 public XTN removePhone(int rep) throws HL7Exception { 842 return (XTN) super.removeRepetition(10, rep); 843 } 844 845 846 /** 847 * Removes a repetition of 848 * STF-10: "Phone" at a specific index 849 * 850 * @param rep The repetition index (0-indexed) 851 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 852 */ 853 public XTN removeStf10_Phone(int rep) throws HL7Exception { 854 return (XTN) super.removeRepetition(10, rep); 855 } 856 857 858 859 /** 860 * Returns all repetitions of Office/Home Address (STF-11). 861 */ 862 public XAD[] getOfficeHomeAddress() { 863 XAD[] retVal = this.getTypedField(11, new XAD[0]); 864 return retVal; 865 } 866 867 868 /** 869 * Returns all repetitions of Office/Home Address (STF-11). 870 */ 871 public XAD[] getStf11_OfficeHomeAddress() { 872 XAD[] retVal = this.getTypedField(11, new XAD[0]); 873 return retVal; 874 } 875 876 877 /** 878 * Returns a count of the current number of repetitions of Office/Home Address (STF-11). 879 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 880 * it will return zero. 881 */ 882 public int getOfficeHomeAddressReps() { 883 return this.getReps(11); 884 } 885 886 887 /** 888 * Returns a specific repetition of 889 * STF-11: "Office/Home Address" - creates it if necessary 890 * 891 * @param rep The repetition index (0-indexed) 892 */ 893 public XAD getOfficeHomeAddress(int rep) { 894 XAD retVal = this.getTypedField(11, rep); 895 return retVal; 896 } 897 898 /** 899 * Returns a specific repetition of 900 * STF-11: "Office/Home Address" - creates it if necessary 901 * 902 * @param rep The repetition index (0-indexed) 903 */ 904 public XAD getStf11_OfficeHomeAddress(int rep) { 905 XAD retVal = this.getTypedField(11, rep); 906 return retVal; 907 } 908 909 /** 910 * Returns a count of the current number of repetitions of Office/Home Address (STF-11). 911 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 912 * it will return zero. 913 */ 914 public int getStf11_OfficeHomeAddressReps() { 915 return this.getReps(11); 916 } 917 918 919 /** 920 * Inserts a repetition of 921 * STF-11: "Office/Home Address" at a specific index 922 * 923 * @param rep The repetition index (0-indexed) 924 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 925 */ 926 public XAD insertOfficeHomeAddress(int rep) throws HL7Exception { 927 return (XAD) super.insertRepetition(11, rep); 928 } 929 930 931 /** 932 * Inserts a repetition of 933 * STF-11: "Office/Home Address" at a specific index 934 * 935 * @param rep The repetition index (0-indexed) 936 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 937 */ 938 public XAD insertStf11_OfficeHomeAddress(int rep) throws HL7Exception { 939 return (XAD) super.insertRepetition(11, rep); 940 } 941 942 943 /** 944 * Removes a repetition of 945 * STF-11: "Office/Home Address" at a specific index 946 * 947 * @param rep The repetition index (0-indexed) 948 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 949 */ 950 public XAD removeOfficeHomeAddress(int rep) throws HL7Exception { 951 return (XAD) super.removeRepetition(11, rep); 952 } 953 954 955 /** 956 * Removes a repetition of 957 * STF-11: "Office/Home Address" at a specific index 958 * 959 * @param rep The repetition index (0-indexed) 960 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 961 */ 962 public XAD removeStf11_OfficeHomeAddress(int rep) throws HL7Exception { 963 return (XAD) super.removeRepetition(11, rep); 964 } 965 966 967 968 /** 969 * Returns all repetitions of Institution Activation Date (STF-12). 970 */ 971 public DIN[] getInstitutionActivationDate() { 972 DIN[] retVal = this.getTypedField(12, new DIN[0]); 973 return retVal; 974 } 975 976 977 /** 978 * Returns all repetitions of Institution Activation Date (STF-12). 979 */ 980 public DIN[] getStf12_InstitutionActivationDate() { 981 DIN[] retVal = this.getTypedField(12, new DIN[0]); 982 return retVal; 983 } 984 985 986 /** 987 * Returns a count of the current number of repetitions of Institution Activation Date (STF-12). 988 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 989 * it will return zero. 990 */ 991 public int getInstitutionActivationDateReps() { 992 return this.getReps(12); 993 } 994 995 996 /** 997 * Returns a specific repetition of 998 * STF-12: "Institution Activation Date" - creates it if necessary 999 * 1000 * @param rep The repetition index (0-indexed) 1001 */ 1002 public DIN getInstitutionActivationDate(int rep) { 1003 DIN retVal = this.getTypedField(12, rep); 1004 return retVal; 1005 } 1006 1007 /** 1008 * Returns a specific repetition of 1009 * STF-12: "Institution Activation Date" - creates it if necessary 1010 * 1011 * @param rep The repetition index (0-indexed) 1012 */ 1013 public DIN getStf12_InstitutionActivationDate(int rep) { 1014 DIN retVal = this.getTypedField(12, rep); 1015 return retVal; 1016 } 1017 1018 /** 1019 * Returns a count of the current number of repetitions of Institution Activation Date (STF-12). 1020 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1021 * it will return zero. 1022 */ 1023 public int getStf12_InstitutionActivationDateReps() { 1024 return this.getReps(12); 1025 } 1026 1027 1028 /** 1029 * Inserts a repetition of 1030 * STF-12: "Institution Activation Date" at a specific index 1031 * 1032 * @param rep The repetition index (0-indexed) 1033 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1034 */ 1035 public DIN insertInstitutionActivationDate(int rep) throws HL7Exception { 1036 return (DIN) super.insertRepetition(12, rep); 1037 } 1038 1039 1040 /** 1041 * Inserts a repetition of 1042 * STF-12: "Institution Activation Date" at a specific index 1043 * 1044 * @param rep The repetition index (0-indexed) 1045 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1046 */ 1047 public DIN insertStf12_InstitutionActivationDate(int rep) throws HL7Exception { 1048 return (DIN) super.insertRepetition(12, rep); 1049 } 1050 1051 1052 /** 1053 * Removes a repetition of 1054 * STF-12: "Institution Activation Date" at a specific index 1055 * 1056 * @param rep The repetition index (0-indexed) 1057 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1058 */ 1059 public DIN removeInstitutionActivationDate(int rep) throws HL7Exception { 1060 return (DIN) super.removeRepetition(12, rep); 1061 } 1062 1063 1064 /** 1065 * Removes a repetition of 1066 * STF-12: "Institution Activation Date" at a specific index 1067 * 1068 * @param rep The repetition index (0-indexed) 1069 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1070 */ 1071 public DIN removeStf12_InstitutionActivationDate(int rep) throws HL7Exception { 1072 return (DIN) super.removeRepetition(12, rep); 1073 } 1074 1075 1076 1077 /** 1078 * Returns all repetitions of Institution Inactivation Date (STF-13). 1079 */ 1080 public DIN[] getInstitutionInactivationDate() { 1081 DIN[] retVal = this.getTypedField(13, new DIN[0]); 1082 return retVal; 1083 } 1084 1085 1086 /** 1087 * Returns all repetitions of Institution Inactivation Date (STF-13). 1088 */ 1089 public DIN[] getStf13_InstitutionInactivationDate() { 1090 DIN[] retVal = this.getTypedField(13, new DIN[0]); 1091 return retVal; 1092 } 1093 1094 1095 /** 1096 * Returns a count of the current number of repetitions of Institution Inactivation Date (STF-13). 1097 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1098 * it will return zero. 1099 */ 1100 public int getInstitutionInactivationDateReps() { 1101 return this.getReps(13); 1102 } 1103 1104 1105 /** 1106 * Returns a specific repetition of 1107 * STF-13: "Institution Inactivation Date" - creates it if necessary 1108 * 1109 * @param rep The repetition index (0-indexed) 1110 */ 1111 public DIN getInstitutionInactivationDate(int rep) { 1112 DIN retVal = this.getTypedField(13, rep); 1113 return retVal; 1114 } 1115 1116 /** 1117 * Returns a specific repetition of 1118 * STF-13: "Institution Inactivation Date" - creates it if necessary 1119 * 1120 * @param rep The repetition index (0-indexed) 1121 */ 1122 public DIN getStf13_InstitutionInactivationDate(int rep) { 1123 DIN retVal = this.getTypedField(13, rep); 1124 return retVal; 1125 } 1126 1127 /** 1128 * Returns a count of the current number of repetitions of Institution Inactivation Date (STF-13). 1129 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1130 * it will return zero. 1131 */ 1132 public int getStf13_InstitutionInactivationDateReps() { 1133 return this.getReps(13); 1134 } 1135 1136 1137 /** 1138 * Inserts a repetition of 1139 * STF-13: "Institution Inactivation Date" at a specific index 1140 * 1141 * @param rep The repetition index (0-indexed) 1142 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1143 */ 1144 public DIN insertInstitutionInactivationDate(int rep) throws HL7Exception { 1145 return (DIN) super.insertRepetition(13, rep); 1146 } 1147 1148 1149 /** 1150 * Inserts a repetition of 1151 * STF-13: "Institution Inactivation Date" at a specific index 1152 * 1153 * @param rep The repetition index (0-indexed) 1154 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1155 */ 1156 public DIN insertStf13_InstitutionInactivationDate(int rep) throws HL7Exception { 1157 return (DIN) super.insertRepetition(13, rep); 1158 } 1159 1160 1161 /** 1162 * Removes a repetition of 1163 * STF-13: "Institution Inactivation Date" at a specific index 1164 * 1165 * @param rep The repetition index (0-indexed) 1166 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1167 */ 1168 public DIN removeInstitutionInactivationDate(int rep) throws HL7Exception { 1169 return (DIN) super.removeRepetition(13, rep); 1170 } 1171 1172 1173 /** 1174 * Removes a repetition of 1175 * STF-13: "Institution Inactivation Date" at a specific index 1176 * 1177 * @param rep The repetition index (0-indexed) 1178 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1179 */ 1180 public DIN removeStf13_InstitutionInactivationDate(int rep) throws HL7Exception { 1181 return (DIN) super.removeRepetition(13, rep); 1182 } 1183 1184 1185 1186 /** 1187 * Returns all repetitions of Backup Person ID (STF-14). 1188 */ 1189 public CE[] getBackupPersonID() { 1190 CE[] retVal = this.getTypedField(14, new CE[0]); 1191 return retVal; 1192 } 1193 1194 1195 /** 1196 * Returns all repetitions of Backup Person ID (STF-14). 1197 */ 1198 public CE[] getStf14_BackupPersonID() { 1199 CE[] retVal = this.getTypedField(14, new CE[0]); 1200 return retVal; 1201 } 1202 1203 1204 /** 1205 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1206 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1207 * it will return zero. 1208 */ 1209 public int getBackupPersonIDReps() { 1210 return this.getReps(14); 1211 } 1212 1213 1214 /** 1215 * Returns a specific repetition of 1216 * STF-14: "Backup Person ID" - creates it if necessary 1217 * 1218 * @param rep The repetition index (0-indexed) 1219 */ 1220 public CE getBackupPersonID(int rep) { 1221 CE retVal = this.getTypedField(14, rep); 1222 return retVal; 1223 } 1224 1225 /** 1226 * Returns a specific repetition of 1227 * STF-14: "Backup Person ID" - creates it if necessary 1228 * 1229 * @param rep The repetition index (0-indexed) 1230 */ 1231 public CE getStf14_BackupPersonID(int rep) { 1232 CE retVal = this.getTypedField(14, rep); 1233 return retVal; 1234 } 1235 1236 /** 1237 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1238 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1239 * it will return zero. 1240 */ 1241 public int getStf14_BackupPersonIDReps() { 1242 return this.getReps(14); 1243 } 1244 1245 1246 /** 1247 * Inserts a repetition of 1248 * STF-14: "Backup Person ID" at a specific index 1249 * 1250 * @param rep The repetition index (0-indexed) 1251 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1252 */ 1253 public CE insertBackupPersonID(int rep) throws HL7Exception { 1254 return (CE) super.insertRepetition(14, rep); 1255 } 1256 1257 1258 /** 1259 * Inserts a repetition of 1260 * STF-14: "Backup Person ID" at a specific index 1261 * 1262 * @param rep The repetition index (0-indexed) 1263 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1264 */ 1265 public CE insertStf14_BackupPersonID(int rep) throws HL7Exception { 1266 return (CE) super.insertRepetition(14, rep); 1267 } 1268 1269 1270 /** 1271 * Removes a repetition of 1272 * STF-14: "Backup Person ID" at a specific index 1273 * 1274 * @param rep The repetition index (0-indexed) 1275 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1276 */ 1277 public CE removeBackupPersonID(int rep) throws HL7Exception { 1278 return (CE) super.removeRepetition(14, rep); 1279 } 1280 1281 1282 /** 1283 * Removes a repetition of 1284 * STF-14: "Backup Person ID" at a specific index 1285 * 1286 * @param rep The repetition index (0-indexed) 1287 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1288 */ 1289 public CE removeStf14_BackupPersonID(int rep) throws HL7Exception { 1290 return (CE) super.removeRepetition(14, rep); 1291 } 1292 1293 1294 1295 /** 1296 * Returns all repetitions of E-Mail Address (STF-15). 1297 */ 1298 public ST[] getEMailAddress() { 1299 ST[] retVal = this.getTypedField(15, new ST[0]); 1300 return retVal; 1301 } 1302 1303 1304 /** 1305 * Returns all repetitions of E-Mail Address (STF-15). 1306 */ 1307 public ST[] getStf15_EMailAddress() { 1308 ST[] retVal = this.getTypedField(15, new ST[0]); 1309 return retVal; 1310 } 1311 1312 1313 /** 1314 * Returns a count of the current number of repetitions of E-Mail Address (STF-15). 1315 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1316 * it will return zero. 1317 */ 1318 public int getEMailAddressReps() { 1319 return this.getReps(15); 1320 } 1321 1322 1323 /** 1324 * Returns a specific repetition of 1325 * STF-15: "E-Mail Address" - creates it if necessary 1326 * 1327 * @param rep The repetition index (0-indexed) 1328 */ 1329 public ST getEMailAddress(int rep) { 1330 ST retVal = this.getTypedField(15, rep); 1331 return retVal; 1332 } 1333 1334 /** 1335 * Returns a specific repetition of 1336 * STF-15: "E-Mail Address" - creates it if necessary 1337 * 1338 * @param rep The repetition index (0-indexed) 1339 */ 1340 public ST getStf15_EMailAddress(int rep) { 1341 ST retVal = this.getTypedField(15, rep); 1342 return retVal; 1343 } 1344 1345 /** 1346 * Returns a count of the current number of repetitions of E-Mail Address (STF-15). 1347 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1348 * it will return zero. 1349 */ 1350 public int getStf15_EMailAddressReps() { 1351 return this.getReps(15); 1352 } 1353 1354 1355 /** 1356 * Inserts a repetition of 1357 * STF-15: "E-Mail Address" at a specific index 1358 * 1359 * @param rep The repetition index (0-indexed) 1360 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1361 */ 1362 public ST insertEMailAddress(int rep) throws HL7Exception { 1363 return (ST) super.insertRepetition(15, rep); 1364 } 1365 1366 1367 /** 1368 * Inserts a repetition of 1369 * STF-15: "E-Mail Address" at a specific index 1370 * 1371 * @param rep The repetition index (0-indexed) 1372 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1373 */ 1374 public ST insertStf15_EMailAddress(int rep) throws HL7Exception { 1375 return (ST) super.insertRepetition(15, rep); 1376 } 1377 1378 1379 /** 1380 * Removes a repetition of 1381 * STF-15: "E-Mail Address" at a specific index 1382 * 1383 * @param rep The repetition index (0-indexed) 1384 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1385 */ 1386 public ST removeEMailAddress(int rep) throws HL7Exception { 1387 return (ST) super.removeRepetition(15, rep); 1388 } 1389 1390 1391 /** 1392 * Removes a repetition of 1393 * STF-15: "E-Mail Address" at a specific index 1394 * 1395 * @param rep The repetition index (0-indexed) 1396 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1397 */ 1398 public ST removeStf15_EMailAddress(int rep) throws HL7Exception { 1399 return (ST) super.removeRepetition(15, rep); 1400 } 1401 1402 1403 1404 1405 /** 1406 * Returns 1407 * STF-16: "Preferred Method Of Contact" - creates it if necessary 1408 */ 1409 public CE getPreferredMethodOfContact() { 1410 CE retVal = this.getTypedField(16, 0); 1411 return retVal; 1412 } 1413 1414 /** 1415 * Returns 1416 * STF-16: "Preferred Method Of Contact" - creates it if necessary 1417 */ 1418 public CE getStf16_PreferredMethodOfContact() { 1419 CE retVal = this.getTypedField(16, 0); 1420 return retVal; 1421 } 1422 1423 1424 1425 /** 1426 * Returns 1427 * STF-17: "Marital Status" - creates it if necessary 1428 */ 1429 public CE getMaritalStatus() { 1430 CE retVal = this.getTypedField(17, 0); 1431 return retVal; 1432 } 1433 1434 /** 1435 * Returns 1436 * STF-17: "Marital Status" - creates it if necessary 1437 */ 1438 public CE getStf17_MaritalStatus() { 1439 CE retVal = this.getTypedField(17, 0); 1440 return retVal; 1441 } 1442 1443 1444 1445 /** 1446 * Returns 1447 * STF-18: "Job Title" - creates it if necessary 1448 */ 1449 public ST getJobTitle() { 1450 ST retVal = this.getTypedField(18, 0); 1451 return retVal; 1452 } 1453 1454 /** 1455 * Returns 1456 * STF-18: "Job Title" - creates it if necessary 1457 */ 1458 public ST getStf18_JobTitle() { 1459 ST retVal = this.getTypedField(18, 0); 1460 return retVal; 1461 } 1462 1463 1464 1465 /** 1466 * Returns 1467 * STF-19: "Job Code/Class" - creates it if necessary 1468 */ 1469 public JCC getJobCodeClass() { 1470 JCC retVal = this.getTypedField(19, 0); 1471 return retVal; 1472 } 1473 1474 /** 1475 * Returns 1476 * STF-19: "Job Code/Class" - creates it if necessary 1477 */ 1478 public JCC getStf19_JobCodeClass() { 1479 JCC retVal = this.getTypedField(19, 0); 1480 return retVal; 1481 } 1482 1483 1484 1485 /** 1486 * Returns 1487 * STF-20: "Employment Status" - creates it if necessary 1488 */ 1489 public IS getEmploymentStatus() { 1490 IS retVal = this.getTypedField(20, 0); 1491 return retVal; 1492 } 1493 1494 /** 1495 * Returns 1496 * STF-20: "Employment Status" - creates it if necessary 1497 */ 1498 public IS getStf20_EmploymentStatus() { 1499 IS retVal = this.getTypedField(20, 0); 1500 return retVal; 1501 } 1502 1503 1504 1505 /** 1506 * Returns 1507 * STF-21: "Additional Insured on Auto" - creates it if necessary 1508 */ 1509 public ID getAdditionalInsuredOnAuto() { 1510 ID retVal = this.getTypedField(21, 0); 1511 return retVal; 1512 } 1513 1514 /** 1515 * Returns 1516 * STF-21: "Additional Insured on Auto" - creates it if necessary 1517 */ 1518 public ID getStf21_AdditionalInsuredOnAuto() { 1519 ID retVal = this.getTypedField(21, 0); 1520 return retVal; 1521 } 1522 1523 1524 1525 /** 1526 * Returns 1527 * STF-22: "Driver’s License Number - Staff" - creates it if necessary 1528 */ 1529 public DLN getDriverSLicenseNumberStaff() { 1530 DLN retVal = this.getTypedField(22, 0); 1531 return retVal; 1532 } 1533 1534 /** 1535 * Returns 1536 * STF-22: "Driver’s License Number - Staff" - creates it if necessary 1537 */ 1538 public DLN getStf22_DriverSLicenseNumberStaff() { 1539 DLN retVal = this.getTypedField(22, 0); 1540 return retVal; 1541 } 1542 1543 1544 1545 /** 1546 * Returns 1547 * STF-23: "Copy Auto Ins" - creates it if necessary 1548 */ 1549 public ID getCopyAutoIns() { 1550 ID retVal = this.getTypedField(23, 0); 1551 return retVal; 1552 } 1553 1554 /** 1555 * Returns 1556 * STF-23: "Copy Auto Ins" - creates it if necessary 1557 */ 1558 public ID getStf23_CopyAutoIns() { 1559 ID retVal = this.getTypedField(23, 0); 1560 return retVal; 1561 } 1562 1563 1564 1565 /** 1566 * Returns 1567 * STF-24: "Auto Ins. Expires" - creates it if necessary 1568 */ 1569 public DT getAutoInsExpires() { 1570 DT retVal = this.getTypedField(24, 0); 1571 return retVal; 1572 } 1573 1574 /** 1575 * Returns 1576 * STF-24: "Auto Ins. Expires" - creates it if necessary 1577 */ 1578 public DT getStf24_AutoInsExpires() { 1579 DT retVal = this.getTypedField(24, 0); 1580 return retVal; 1581 } 1582 1583 1584 1585 /** 1586 * Returns 1587 * STF-25: "Date Last DMV Review" - creates it if necessary 1588 */ 1589 public DT getDateLastDMVReview() { 1590 DT retVal = this.getTypedField(25, 0); 1591 return retVal; 1592 } 1593 1594 /** 1595 * Returns 1596 * STF-25: "Date Last DMV Review" - creates it if necessary 1597 */ 1598 public DT getStf25_DateLastDMVReview() { 1599 DT retVal = this.getTypedField(25, 0); 1600 return retVal; 1601 } 1602 1603 1604 1605 /** 1606 * Returns 1607 * STF-26: "Date Next DMV Review" - creates it if necessary 1608 */ 1609 public DT getDateNextDMVReview() { 1610 DT retVal = this.getTypedField(26, 0); 1611 return retVal; 1612 } 1613 1614 /** 1615 * Returns 1616 * STF-26: "Date Next DMV Review" - creates it if necessary 1617 */ 1618 public DT getStf26_DateNextDMVReview() { 1619 DT retVal = this.getTypedField(26, 0); 1620 return retVal; 1621 } 1622 1623 1624 1625 1626 1627 /** {@inheritDoc} */ 1628 protected Type createNewTypeWithoutReflection(int field) { 1629 switch (field) { 1630 case 0: return new CE(getMessage()); 1631 case 1: return new CX(getMessage()); 1632 case 2: return new XPN(getMessage()); 1633 case 3: return new IS(getMessage(), new Integer( 182 )); 1634 case 4: return new IS(getMessage(), new Integer( 1 )); 1635 case 5: return new TS(getMessage()); 1636 case 6: return new ID(getMessage(), new Integer( 183 )); 1637 case 7: return new CE(getMessage()); 1638 case 8: return new CE(getMessage()); 1639 case 9: return new XTN(getMessage()); 1640 case 10: return new XAD(getMessage()); 1641 case 11: return new DIN(getMessage()); 1642 case 12: return new DIN(getMessage()); 1643 case 13: return new CE(getMessage()); 1644 case 14: return new ST(getMessage()); 1645 case 15: return new CE(getMessage()); 1646 case 16: return new CE(getMessage()); 1647 case 17: return new ST(getMessage()); 1648 case 18: return new JCC(getMessage()); 1649 case 19: return new IS(getMessage(), new Integer( 66 )); 1650 case 20: return new ID(getMessage(), new Integer( 136 )); 1651 case 21: return new DLN(getMessage()); 1652 case 22: return new ID(getMessage(), new Integer( 136 )); 1653 case 23: return new DT(getMessage()); 1654 case 24: return new DT(getMessage()); 1655 case 25: return new DT(getMessage()); 1656 default: return null; 1657 } 1658 } 1659 1660 1661} 1662