001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v23.segment; 035 036// import ca.uhn.hl7v2.model.v23.group.*; 037import ca.uhn.hl7v2.model.v23.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 STF message segment (Staff identification segment). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>STF-1: STF - Primary Key Value (CE) <b> </b> 053 * <li>STF-2: Staff ID Code (CE) <b>optional repeating</b> 054 * <li>STF-3: Staff Name (XPN) <b>optional </b> 055 * <li>STF-4: Staff Type (ID) <b>optional repeating</b> 056 * <li>STF-5: Sex (IS) <b>optional </b> 057 * <li>STF-6: Date 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: Service (CE) <b>optional repeating</b> 061 * <li>STF-10: Phone (XTN) <b>optional repeating</b> 062 * <li>STF-11: Office/Home Address (AD) <b>optional repeating</b> 063 * <li>STF-12: Activation Date (CM_DIN) <b>optional repeating</b> 064 * <li>STF-13: Inactivation Date (CM_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 (IS) <b>optional repeating</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 (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() }, "STF - Primary Key Value"); 094 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Staff ID Code"); 095 this.add(XPN.class, false, 1, 48, new Object[]{ getMessage() }, "Staff Name"); 096 this.add(ID.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 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() }, "Service"); 102 this.add(XTN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone"); 103 this.add(AD.class, false, 2, 106, new Object[]{ getMessage() }, "Office/Home Address"); 104 this.add(CM_DIN.class, false, 0, 26, new Object[]{ getMessage() }, "Activation Date"); 105 this.add(CM_DIN.class, false, 0, 26, new Object[]{ getMessage() }, "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(IS.class, false, 0, 1, new Object[]{ getMessage(), new Integer(2) }, "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"); 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: "STF - Primary Key Value" - creates it if necessary 129 */ 130 public CE getSTFPrimaryKeyValue() { 131 CE retVal = this.getTypedField(1, 0); 132 return retVal; 133 } 134 135 /** 136 * Returns 137 * STF-1: "STF - Primary Key Value" - creates it if necessary 138 */ 139 public CE getStf1_STFPrimaryKeyValue() { 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 CE[] getStaffIDCode() { 149 CE[] retVal = this.getTypedField(2, new CE[0]); 150 return retVal; 151 } 152 153 154 /** 155 * Returns all repetitions of Staff ID Code (STF-2). 156 */ 157 public CE[] getStf2_StaffIDCode() { 158 CE[] retVal = this.getTypedField(2, new CE[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 CE getStaffIDCode(int rep) { 180 CE 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 CE getStf2_StaffIDCode(int rep) { 191 CE 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 CE insertStaffIDCode(int rep) throws HL7Exception { 213 return (CE) 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 CE insertStf2_StaffIDCode(int rep) throws HL7Exception { 225 return (CE) 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 CE removeStaffIDCode(int rep) throws HL7Exception { 237 return (CE) 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 CE removeStf2_StaffIDCode(int rep) throws HL7Exception { 249 return (CE) super.removeRepetition(2, rep); 250 } 251 252 253 254 255 /** 256 * Returns 257 * STF-3: "Staff Name" - creates it if necessary 258 */ 259 public XPN getStaffName() { 260 XPN retVal = this.getTypedField(3, 0); 261 return retVal; 262 } 263 264 /** 265 * Returns 266 * STF-3: "Staff Name" - creates it if necessary 267 */ 268 public XPN getStf3_StaffName() { 269 XPN retVal = this.getTypedField(3, 0); 270 return retVal; 271 } 272 273 274 /** 275 * Returns all repetitions of Staff Type (STF-4). 276 */ 277 public ID[] getStaffType() { 278 ID[] retVal = this.getTypedField(4, new ID[0]); 279 return retVal; 280 } 281 282 283 /** 284 * Returns all repetitions of Staff Type (STF-4). 285 */ 286 public ID[] getStf4_StaffType() { 287 ID[] retVal = this.getTypedField(4, new ID[0]); 288 return retVal; 289 } 290 291 292 /** 293 * Returns a count of the current number of repetitions of Staff Type (STF-4). 294 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 295 * it will return zero. 296 */ 297 public int getStaffTypeReps() { 298 return this.getReps(4); 299 } 300 301 302 /** 303 * Returns a specific repetition of 304 * STF-4: "Staff Type" - creates it if necessary 305 * 306 * @param rep The repetition index (0-indexed) 307 */ 308 public ID getStaffType(int rep) { 309 ID retVal = this.getTypedField(4, rep); 310 return retVal; 311 } 312 313 /** 314 * Returns a specific repetition of 315 * STF-4: "Staff Type" - creates it if necessary 316 * 317 * @param rep The repetition index (0-indexed) 318 */ 319 public ID getStf4_StaffType(int rep) { 320 ID retVal = this.getTypedField(4, rep); 321 return retVal; 322 } 323 324 /** 325 * Returns a count of the current number of repetitions of Staff Type (STF-4). 326 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 327 * it will return zero. 328 */ 329 public int getStf4_StaffTypeReps() { 330 return this.getReps(4); 331 } 332 333 334 /** 335 * Inserts a repetition of 336 * STF-4: "Staff Type" at a specific index 337 * 338 * @param rep The repetition index (0-indexed) 339 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 340 */ 341 public ID insertStaffType(int rep) throws HL7Exception { 342 return (ID) super.insertRepetition(4, rep); 343 } 344 345 346 /** 347 * Inserts a repetition of 348 * STF-4: "Staff Type" at a specific index 349 * 350 * @param rep The repetition index (0-indexed) 351 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 352 */ 353 public ID insertStf4_StaffType(int rep) throws HL7Exception { 354 return (ID) super.insertRepetition(4, rep); 355 } 356 357 358 /** 359 * Removes a repetition of 360 * STF-4: "Staff Type" at a specific index 361 * 362 * @param rep The repetition index (0-indexed) 363 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 364 */ 365 public ID removeStaffType(int rep) throws HL7Exception { 366 return (ID) super.removeRepetition(4, rep); 367 } 368 369 370 /** 371 * Removes a repetition of 372 * STF-4: "Staff Type" at a specific index 373 * 374 * @param rep The repetition index (0-indexed) 375 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 376 */ 377 public ID removeStf4_StaffType(int rep) throws HL7Exception { 378 return (ID) super.removeRepetition(4, rep); 379 } 380 381 382 383 384 /** 385 * Returns 386 * STF-5: "Sex" - creates it if necessary 387 */ 388 public IS getSex() { 389 IS retVal = this.getTypedField(5, 0); 390 return retVal; 391 } 392 393 /** 394 * Returns 395 * STF-5: "Sex" - creates it if necessary 396 */ 397 public IS getStf5_Sex() { 398 IS retVal = this.getTypedField(5, 0); 399 return retVal; 400 } 401 402 403 404 /** 405 * Returns 406 * STF-6: "Date of Birth" - creates it if necessary 407 */ 408 public TS getDateOfBirth() { 409 TS retVal = this.getTypedField(6, 0); 410 return retVal; 411 } 412 413 /** 414 * Returns 415 * STF-6: "Date of Birth" - creates it if necessary 416 */ 417 public TS getStf6_DateOfBirth() { 418 TS retVal = this.getTypedField(6, 0); 419 return retVal; 420 } 421 422 423 424 /** 425 * Returns 426 * STF-7: "Active/Inactive Flag" - creates it if necessary 427 */ 428 public ID getActiveInactiveFlag() { 429 ID retVal = this.getTypedField(7, 0); 430 return retVal; 431 } 432 433 /** 434 * Returns 435 * STF-7: "Active/Inactive Flag" - creates it if necessary 436 */ 437 public ID getStf7_ActiveInactiveFlag() { 438 ID retVal = this.getTypedField(7, 0); 439 return retVal; 440 } 441 442 443 /** 444 * Returns all repetitions of Department (STF-8). 445 */ 446 public CE[] getDepartment() { 447 CE[] retVal = this.getTypedField(8, new CE[0]); 448 return retVal; 449 } 450 451 452 /** 453 * Returns all repetitions of Department (STF-8). 454 */ 455 public CE[] getStf8_Department() { 456 CE[] retVal = this.getTypedField(8, new CE[0]); 457 return retVal; 458 } 459 460 461 /** 462 * Returns a count of the current number of repetitions of Department (STF-8). 463 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 464 * it will return zero. 465 */ 466 public int getDepartmentReps() { 467 return this.getReps(8); 468 } 469 470 471 /** 472 * Returns a specific repetition of 473 * STF-8: "Department" - creates it if necessary 474 * 475 * @param rep The repetition index (0-indexed) 476 */ 477 public CE getDepartment(int rep) { 478 CE retVal = this.getTypedField(8, rep); 479 return retVal; 480 } 481 482 /** 483 * Returns a specific repetition of 484 * STF-8: "Department" - creates it if necessary 485 * 486 * @param rep The repetition index (0-indexed) 487 */ 488 public CE getStf8_Department(int rep) { 489 CE retVal = this.getTypedField(8, rep); 490 return retVal; 491 } 492 493 /** 494 * Returns a count of the current number of repetitions of Department (STF-8). 495 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 496 * it will return zero. 497 */ 498 public int getStf8_DepartmentReps() { 499 return this.getReps(8); 500 } 501 502 503 /** 504 * Inserts a repetition of 505 * STF-8: "Department" at a specific index 506 * 507 * @param rep The repetition index (0-indexed) 508 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 509 */ 510 public CE insertDepartment(int rep) throws HL7Exception { 511 return (CE) super.insertRepetition(8, rep); 512 } 513 514 515 /** 516 * Inserts a repetition of 517 * STF-8: "Department" at a specific index 518 * 519 * @param rep The repetition index (0-indexed) 520 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 521 */ 522 public CE insertStf8_Department(int rep) throws HL7Exception { 523 return (CE) super.insertRepetition(8, rep); 524 } 525 526 527 /** 528 * Removes a repetition of 529 * STF-8: "Department" at a specific index 530 * 531 * @param rep The repetition index (0-indexed) 532 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 533 */ 534 public CE removeDepartment(int rep) throws HL7Exception { 535 return (CE) super.removeRepetition(8, rep); 536 } 537 538 539 /** 540 * Removes a repetition of 541 * STF-8: "Department" at a specific index 542 * 543 * @param rep The repetition index (0-indexed) 544 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 545 */ 546 public CE removeStf8_Department(int rep) throws HL7Exception { 547 return (CE) super.removeRepetition(8, rep); 548 } 549 550 551 552 /** 553 * Returns all repetitions of Service (STF-9). 554 */ 555 public CE[] getService() { 556 CE[] retVal = this.getTypedField(9, new CE[0]); 557 return retVal; 558 } 559 560 561 /** 562 * Returns all repetitions of Service (STF-9). 563 */ 564 public CE[] getStf9_Service() { 565 CE[] retVal = this.getTypedField(9, new CE[0]); 566 return retVal; 567 } 568 569 570 /** 571 * Returns a count of the current number of repetitions of Service (STF-9). 572 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 573 * it will return zero. 574 */ 575 public int getServiceReps() { 576 return this.getReps(9); 577 } 578 579 580 /** 581 * Returns a specific repetition of 582 * STF-9: "Service" - creates it if necessary 583 * 584 * @param rep The repetition index (0-indexed) 585 */ 586 public CE getService(int rep) { 587 CE retVal = this.getTypedField(9, rep); 588 return retVal; 589 } 590 591 /** 592 * Returns a specific repetition of 593 * STF-9: "Service" - creates it if necessary 594 * 595 * @param rep The repetition index (0-indexed) 596 */ 597 public CE getStf9_Service(int rep) { 598 CE retVal = this.getTypedField(9, rep); 599 return retVal; 600 } 601 602 /** 603 * Returns a count of the current number of repetitions of Service (STF-9). 604 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 605 * it will return zero. 606 */ 607 public int getStf9_ServiceReps() { 608 return this.getReps(9); 609 } 610 611 612 /** 613 * Inserts a repetition of 614 * STF-9: "Service" at a specific index 615 * 616 * @param rep The repetition index (0-indexed) 617 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 618 */ 619 public CE insertService(int rep) throws HL7Exception { 620 return (CE) super.insertRepetition(9, rep); 621 } 622 623 624 /** 625 * Inserts a repetition of 626 * STF-9: "Service" at a specific index 627 * 628 * @param rep The repetition index (0-indexed) 629 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 630 */ 631 public CE insertStf9_Service(int rep) throws HL7Exception { 632 return (CE) super.insertRepetition(9, rep); 633 } 634 635 636 /** 637 * Removes a repetition of 638 * STF-9: "Service" at a specific index 639 * 640 * @param rep The repetition index (0-indexed) 641 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 642 */ 643 public CE removeService(int rep) throws HL7Exception { 644 return (CE) super.removeRepetition(9, rep); 645 } 646 647 648 /** 649 * Removes a repetition of 650 * STF-9: "Service" at a specific index 651 * 652 * @param rep The repetition index (0-indexed) 653 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 654 */ 655 public CE removeStf9_Service(int rep) throws HL7Exception { 656 return (CE) super.removeRepetition(9, rep); 657 } 658 659 660 661 /** 662 * Returns all repetitions of Phone (STF-10). 663 */ 664 public XTN[] getPhone() { 665 XTN[] retVal = this.getTypedField(10, new XTN[0]); 666 return retVal; 667 } 668 669 670 /** 671 * Returns all repetitions of Phone (STF-10). 672 */ 673 public XTN[] getStf10_Phone() { 674 XTN[] retVal = this.getTypedField(10, new XTN[0]); 675 return retVal; 676 } 677 678 679 /** 680 * Returns a count of the current number of repetitions of Phone (STF-10). 681 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 682 * it will return zero. 683 */ 684 public int getPhoneReps() { 685 return this.getReps(10); 686 } 687 688 689 /** 690 * Returns a specific repetition of 691 * STF-10: "Phone" - creates it if necessary 692 * 693 * @param rep The repetition index (0-indexed) 694 */ 695 public XTN getPhone(int rep) { 696 XTN retVal = this.getTypedField(10, rep); 697 return retVal; 698 } 699 700 /** 701 * Returns a specific repetition of 702 * STF-10: "Phone" - creates it if necessary 703 * 704 * @param rep The repetition index (0-indexed) 705 */ 706 public XTN getStf10_Phone(int rep) { 707 XTN retVal = this.getTypedField(10, rep); 708 return retVal; 709 } 710 711 /** 712 * Returns a count of the current number of repetitions of Phone (STF-10). 713 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 714 * it will return zero. 715 */ 716 public int getStf10_PhoneReps() { 717 return this.getReps(10); 718 } 719 720 721 /** 722 * Inserts a repetition of 723 * STF-10: "Phone" at a specific index 724 * 725 * @param rep The repetition index (0-indexed) 726 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 727 */ 728 public XTN insertPhone(int rep) throws HL7Exception { 729 return (XTN) super.insertRepetition(10, rep); 730 } 731 732 733 /** 734 * Inserts a repetition of 735 * STF-10: "Phone" at a specific index 736 * 737 * @param rep The repetition index (0-indexed) 738 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 739 */ 740 public XTN insertStf10_Phone(int rep) throws HL7Exception { 741 return (XTN) super.insertRepetition(10, rep); 742 } 743 744 745 /** 746 * Removes a repetition of 747 * STF-10: "Phone" at a specific index 748 * 749 * @param rep The repetition index (0-indexed) 750 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 751 */ 752 public XTN removePhone(int rep) throws HL7Exception { 753 return (XTN) super.removeRepetition(10, rep); 754 } 755 756 757 /** 758 * Removes a repetition of 759 * STF-10: "Phone" at a specific index 760 * 761 * @param rep The repetition index (0-indexed) 762 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 763 */ 764 public XTN removeStf10_Phone(int rep) throws HL7Exception { 765 return (XTN) super.removeRepetition(10, rep); 766 } 767 768 769 770 /** 771 * Returns all repetitions of Office/Home Address (STF-11). 772 */ 773 public AD[] getOfficeHomeAddress() { 774 AD[] retVal = this.getTypedField(11, new AD[0]); 775 return retVal; 776 } 777 778 779 /** 780 * Returns all repetitions of Office/Home Address (STF-11). 781 */ 782 public AD[] getStf11_OfficeHomeAddress() { 783 AD[] retVal = this.getTypedField(11, new AD[0]); 784 return retVal; 785 } 786 787 788 /** 789 * Returns a count of the current number of repetitions of Office/Home Address (STF-11). 790 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 791 * it will return zero. 792 */ 793 public int getOfficeHomeAddressReps() { 794 return this.getReps(11); 795 } 796 797 798 /** 799 * Returns a specific repetition of 800 * STF-11: "Office/Home Address" - creates it if necessary 801 * 802 * @param rep The repetition index (0-indexed) 803 */ 804 public AD getOfficeHomeAddress(int rep) { 805 AD retVal = this.getTypedField(11, rep); 806 return retVal; 807 } 808 809 /** 810 * Returns a specific repetition of 811 * STF-11: "Office/Home Address" - creates it if necessary 812 * 813 * @param rep The repetition index (0-indexed) 814 */ 815 public AD getStf11_OfficeHomeAddress(int rep) { 816 AD retVal = this.getTypedField(11, rep); 817 return retVal; 818 } 819 820 /** 821 * Returns a count of the current number of repetitions of Office/Home Address (STF-11). 822 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 823 * it will return zero. 824 */ 825 public int getStf11_OfficeHomeAddressReps() { 826 return this.getReps(11); 827 } 828 829 830 /** 831 * Inserts a repetition of 832 * STF-11: "Office/Home Address" at a specific index 833 * 834 * @param rep The repetition index (0-indexed) 835 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 836 */ 837 public AD insertOfficeHomeAddress(int rep) throws HL7Exception { 838 return (AD) super.insertRepetition(11, rep); 839 } 840 841 842 /** 843 * Inserts a repetition of 844 * STF-11: "Office/Home Address" at a specific index 845 * 846 * @param rep The repetition index (0-indexed) 847 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 848 */ 849 public AD insertStf11_OfficeHomeAddress(int rep) throws HL7Exception { 850 return (AD) super.insertRepetition(11, rep); 851 } 852 853 854 /** 855 * Removes a repetition of 856 * STF-11: "Office/Home Address" at a specific index 857 * 858 * @param rep The repetition index (0-indexed) 859 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 860 */ 861 public AD removeOfficeHomeAddress(int rep) throws HL7Exception { 862 return (AD) super.removeRepetition(11, rep); 863 } 864 865 866 /** 867 * Removes a repetition of 868 * STF-11: "Office/Home Address" at a specific index 869 * 870 * @param rep The repetition index (0-indexed) 871 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 872 */ 873 public AD removeStf11_OfficeHomeAddress(int rep) throws HL7Exception { 874 return (AD) super.removeRepetition(11, rep); 875 } 876 877 878 879 /** 880 * Returns all repetitions of Activation Date (STF-12). 881 */ 882 public CM_DIN[] getActivationDate() { 883 CM_DIN[] retVal = this.getTypedField(12, new CM_DIN[0]); 884 return retVal; 885 } 886 887 888 /** 889 * Returns all repetitions of Activation Date (STF-12). 890 */ 891 public CM_DIN[] getStf12_ActivationDate() { 892 CM_DIN[] retVal = this.getTypedField(12, new CM_DIN[0]); 893 return retVal; 894 } 895 896 897 /** 898 * Returns a count of the current number of repetitions of Activation Date (STF-12). 899 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 900 * it will return zero. 901 */ 902 public int getActivationDateReps() { 903 return this.getReps(12); 904 } 905 906 907 /** 908 * Returns a specific repetition of 909 * STF-12: "Activation Date" - creates it if necessary 910 * 911 * @param rep The repetition index (0-indexed) 912 */ 913 public CM_DIN getActivationDate(int rep) { 914 CM_DIN retVal = this.getTypedField(12, rep); 915 return retVal; 916 } 917 918 /** 919 * Returns a specific repetition of 920 * STF-12: "Activation Date" - creates it if necessary 921 * 922 * @param rep The repetition index (0-indexed) 923 */ 924 public CM_DIN getStf12_ActivationDate(int rep) { 925 CM_DIN retVal = this.getTypedField(12, rep); 926 return retVal; 927 } 928 929 /** 930 * Returns a count of the current number of repetitions of Activation Date (STF-12). 931 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 932 * it will return zero. 933 */ 934 public int getStf12_ActivationDateReps() { 935 return this.getReps(12); 936 } 937 938 939 /** 940 * Inserts a repetition of 941 * STF-12: "Activation Date" at a specific index 942 * 943 * @param rep The repetition index (0-indexed) 944 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 945 */ 946 public CM_DIN insertActivationDate(int rep) throws HL7Exception { 947 return (CM_DIN) super.insertRepetition(12, rep); 948 } 949 950 951 /** 952 * Inserts a repetition of 953 * STF-12: "Activation Date" at a specific index 954 * 955 * @param rep The repetition index (0-indexed) 956 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 957 */ 958 public CM_DIN insertStf12_ActivationDate(int rep) throws HL7Exception { 959 return (CM_DIN) super.insertRepetition(12, rep); 960 } 961 962 963 /** 964 * Removes a repetition of 965 * STF-12: "Activation Date" at a specific index 966 * 967 * @param rep The repetition index (0-indexed) 968 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 969 */ 970 public CM_DIN removeActivationDate(int rep) throws HL7Exception { 971 return (CM_DIN) super.removeRepetition(12, rep); 972 } 973 974 975 /** 976 * Removes a repetition of 977 * STF-12: "Activation Date" at a specific index 978 * 979 * @param rep The repetition index (0-indexed) 980 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 981 */ 982 public CM_DIN removeStf12_ActivationDate(int rep) throws HL7Exception { 983 return (CM_DIN) super.removeRepetition(12, rep); 984 } 985 986 987 988 /** 989 * Returns all repetitions of Inactivation Date (STF-13). 990 */ 991 public CM_DIN[] getInactivationDate() { 992 CM_DIN[] retVal = this.getTypedField(13, new CM_DIN[0]); 993 return retVal; 994 } 995 996 997 /** 998 * Returns all repetitions of Inactivation Date (STF-13). 999 */ 1000 public CM_DIN[] getStf13_InactivationDate() { 1001 CM_DIN[] retVal = this.getTypedField(13, new CM_DIN[0]); 1002 return retVal; 1003 } 1004 1005 1006 /** 1007 * Returns a count of the current number of repetitions of Inactivation Date (STF-13). 1008 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1009 * it will return zero. 1010 */ 1011 public int getInactivationDateReps() { 1012 return this.getReps(13); 1013 } 1014 1015 1016 /** 1017 * Returns a specific repetition of 1018 * STF-13: "Inactivation Date" - creates it if necessary 1019 * 1020 * @param rep The repetition index (0-indexed) 1021 */ 1022 public CM_DIN getInactivationDate(int rep) { 1023 CM_DIN retVal = this.getTypedField(13, rep); 1024 return retVal; 1025 } 1026 1027 /** 1028 * Returns a specific repetition of 1029 * STF-13: "Inactivation Date" - creates it if necessary 1030 * 1031 * @param rep The repetition index (0-indexed) 1032 */ 1033 public CM_DIN getStf13_InactivationDate(int rep) { 1034 CM_DIN retVal = this.getTypedField(13, rep); 1035 return retVal; 1036 } 1037 1038 /** 1039 * Returns a count of the current number of repetitions of Inactivation Date (STF-13). 1040 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1041 * it will return zero. 1042 */ 1043 public int getStf13_InactivationDateReps() { 1044 return this.getReps(13); 1045 } 1046 1047 1048 /** 1049 * Inserts a repetition of 1050 * STF-13: "Inactivation Date" at a specific index 1051 * 1052 * @param rep The repetition index (0-indexed) 1053 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1054 */ 1055 public CM_DIN insertInactivationDate(int rep) throws HL7Exception { 1056 return (CM_DIN) super.insertRepetition(13, rep); 1057 } 1058 1059 1060 /** 1061 * Inserts a repetition of 1062 * STF-13: "Inactivation Date" at a specific index 1063 * 1064 * @param rep The repetition index (0-indexed) 1065 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1066 */ 1067 public CM_DIN insertStf13_InactivationDate(int rep) throws HL7Exception { 1068 return (CM_DIN) super.insertRepetition(13, rep); 1069 } 1070 1071 1072 /** 1073 * Removes a repetition of 1074 * STF-13: "Inactivation Date" at a specific index 1075 * 1076 * @param rep The repetition index (0-indexed) 1077 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1078 */ 1079 public CM_DIN removeInactivationDate(int rep) throws HL7Exception { 1080 return (CM_DIN) super.removeRepetition(13, rep); 1081 } 1082 1083 1084 /** 1085 * Removes a repetition of 1086 * STF-13: "Inactivation Date" at a specific index 1087 * 1088 * @param rep The repetition index (0-indexed) 1089 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1090 */ 1091 public CM_DIN removeStf13_InactivationDate(int rep) throws HL7Exception { 1092 return (CM_DIN) super.removeRepetition(13, rep); 1093 } 1094 1095 1096 1097 /** 1098 * Returns all repetitions of Backup Person ID (STF-14). 1099 */ 1100 public CE[] getBackupPersonID() { 1101 CE[] retVal = this.getTypedField(14, new CE[0]); 1102 return retVal; 1103 } 1104 1105 1106 /** 1107 * Returns all repetitions of Backup Person ID (STF-14). 1108 */ 1109 public CE[] getStf14_BackupPersonID() { 1110 CE[] retVal = this.getTypedField(14, new CE[0]); 1111 return retVal; 1112 } 1113 1114 1115 /** 1116 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1117 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1118 * it will return zero. 1119 */ 1120 public int getBackupPersonIDReps() { 1121 return this.getReps(14); 1122 } 1123 1124 1125 /** 1126 * Returns a specific repetition of 1127 * STF-14: "Backup Person ID" - creates it if necessary 1128 * 1129 * @param rep The repetition index (0-indexed) 1130 */ 1131 public CE getBackupPersonID(int rep) { 1132 CE retVal = this.getTypedField(14, rep); 1133 return retVal; 1134 } 1135 1136 /** 1137 * Returns a specific repetition of 1138 * STF-14: "Backup Person ID" - creates it if necessary 1139 * 1140 * @param rep The repetition index (0-indexed) 1141 */ 1142 public CE getStf14_BackupPersonID(int rep) { 1143 CE retVal = this.getTypedField(14, rep); 1144 return retVal; 1145 } 1146 1147 /** 1148 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1149 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1150 * it will return zero. 1151 */ 1152 public int getStf14_BackupPersonIDReps() { 1153 return this.getReps(14); 1154 } 1155 1156 1157 /** 1158 * Inserts a repetition of 1159 * STF-14: "Backup Person ID" at a specific index 1160 * 1161 * @param rep The repetition index (0-indexed) 1162 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1163 */ 1164 public CE insertBackupPersonID(int rep) throws HL7Exception { 1165 return (CE) super.insertRepetition(14, rep); 1166 } 1167 1168 1169 /** 1170 * Inserts a repetition of 1171 * STF-14: "Backup Person ID" at a specific index 1172 * 1173 * @param rep The repetition index (0-indexed) 1174 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1175 */ 1176 public CE insertStf14_BackupPersonID(int rep) throws HL7Exception { 1177 return (CE) super.insertRepetition(14, rep); 1178 } 1179 1180 1181 /** 1182 * Removes a repetition of 1183 * STF-14: "Backup Person ID" at a specific index 1184 * 1185 * @param rep The repetition index (0-indexed) 1186 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1187 */ 1188 public CE removeBackupPersonID(int rep) throws HL7Exception { 1189 return (CE) super.removeRepetition(14, rep); 1190 } 1191 1192 1193 /** 1194 * Removes a repetition of 1195 * STF-14: "Backup Person ID" at a specific index 1196 * 1197 * @param rep The repetition index (0-indexed) 1198 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1199 */ 1200 public CE removeStf14_BackupPersonID(int rep) throws HL7Exception { 1201 return (CE) super.removeRepetition(14, rep); 1202 } 1203 1204 1205 1206 /** 1207 * Returns all repetitions of E-mail Address (STF-15). 1208 */ 1209 public ST[] getEMailAddress() { 1210 ST[] retVal = this.getTypedField(15, new ST[0]); 1211 return retVal; 1212 } 1213 1214 1215 /** 1216 * Returns all repetitions of E-mail Address (STF-15). 1217 */ 1218 public ST[] getStf15_EMailAddress() { 1219 ST[] retVal = this.getTypedField(15, new ST[0]); 1220 return retVal; 1221 } 1222 1223 1224 /** 1225 * Returns a count of the current number of repetitions of E-mail Address (STF-15). 1226 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1227 * it will return zero. 1228 */ 1229 public int getEMailAddressReps() { 1230 return this.getReps(15); 1231 } 1232 1233 1234 /** 1235 * Returns a specific repetition of 1236 * STF-15: "E-mail Address" - creates it if necessary 1237 * 1238 * @param rep The repetition index (0-indexed) 1239 */ 1240 public ST getEMailAddress(int rep) { 1241 ST retVal = this.getTypedField(15, rep); 1242 return retVal; 1243 } 1244 1245 /** 1246 * Returns a specific repetition of 1247 * STF-15: "E-mail Address" - creates it if necessary 1248 * 1249 * @param rep The repetition index (0-indexed) 1250 */ 1251 public ST getStf15_EMailAddress(int rep) { 1252 ST retVal = this.getTypedField(15, rep); 1253 return retVal; 1254 } 1255 1256 /** 1257 * Returns a count of the current number of repetitions of E-mail Address (STF-15). 1258 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1259 * it will return zero. 1260 */ 1261 public int getStf15_EMailAddressReps() { 1262 return this.getReps(15); 1263 } 1264 1265 1266 /** 1267 * Inserts a repetition of 1268 * STF-15: "E-mail Address" at a specific index 1269 * 1270 * @param rep The repetition index (0-indexed) 1271 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1272 */ 1273 public ST insertEMailAddress(int rep) throws HL7Exception { 1274 return (ST) super.insertRepetition(15, rep); 1275 } 1276 1277 1278 /** 1279 * Inserts a repetition of 1280 * STF-15: "E-mail Address" at a specific index 1281 * 1282 * @param rep The repetition index (0-indexed) 1283 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1284 */ 1285 public ST insertStf15_EMailAddress(int rep) throws HL7Exception { 1286 return (ST) super.insertRepetition(15, rep); 1287 } 1288 1289 1290 /** 1291 * Removes a repetition of 1292 * STF-15: "E-mail Address" at a specific index 1293 * 1294 * @param rep The repetition index (0-indexed) 1295 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1296 */ 1297 public ST removeEMailAddress(int rep) throws HL7Exception { 1298 return (ST) super.removeRepetition(15, rep); 1299 } 1300 1301 1302 /** 1303 * Removes a repetition of 1304 * STF-15: "E-mail Address" at a specific index 1305 * 1306 * @param rep The repetition index (0-indexed) 1307 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1308 */ 1309 public ST removeStf15_EMailAddress(int rep) throws HL7Exception { 1310 return (ST) super.removeRepetition(15, rep); 1311 } 1312 1313 1314 1315 1316 /** 1317 * Returns 1318 * STF-16: "Preferred Method of Contact" - creates it if necessary 1319 */ 1320 public CE getPreferredMethodOfContact() { 1321 CE retVal = this.getTypedField(16, 0); 1322 return retVal; 1323 } 1324 1325 /** 1326 * Returns 1327 * STF-16: "Preferred Method of Contact" - creates it if necessary 1328 */ 1329 public CE getStf16_PreferredMethodOfContact() { 1330 CE retVal = this.getTypedField(16, 0); 1331 return retVal; 1332 } 1333 1334 1335 /** 1336 * Returns all repetitions of Marital Status (STF-17). 1337 */ 1338 public IS[] getMaritalStatus() { 1339 IS[] retVal = this.getTypedField(17, new IS[0]); 1340 return retVal; 1341 } 1342 1343 1344 /** 1345 * Returns all repetitions of Marital Status (STF-17). 1346 */ 1347 public IS[] getStf17_MaritalStatus() { 1348 IS[] retVal = this.getTypedField(17, new IS[0]); 1349 return retVal; 1350 } 1351 1352 1353 /** 1354 * Returns a count of the current number of repetitions of Marital Status (STF-17). 1355 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1356 * it will return zero. 1357 */ 1358 public int getMaritalStatusReps() { 1359 return this.getReps(17); 1360 } 1361 1362 1363 /** 1364 * Returns a specific repetition of 1365 * STF-17: "Marital Status" - creates it if necessary 1366 * 1367 * @param rep The repetition index (0-indexed) 1368 */ 1369 public IS getMaritalStatus(int rep) { 1370 IS retVal = this.getTypedField(17, rep); 1371 return retVal; 1372 } 1373 1374 /** 1375 * Returns a specific repetition of 1376 * STF-17: "Marital Status" - creates it if necessary 1377 * 1378 * @param rep The repetition index (0-indexed) 1379 */ 1380 public IS getStf17_MaritalStatus(int rep) { 1381 IS retVal = this.getTypedField(17, rep); 1382 return retVal; 1383 } 1384 1385 /** 1386 * Returns a count of the current number of repetitions of Marital Status (STF-17). 1387 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1388 * it will return zero. 1389 */ 1390 public int getStf17_MaritalStatusReps() { 1391 return this.getReps(17); 1392 } 1393 1394 1395 /** 1396 * Inserts a repetition of 1397 * STF-17: "Marital Status" at a specific index 1398 * 1399 * @param rep The repetition index (0-indexed) 1400 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1401 */ 1402 public IS insertMaritalStatus(int rep) throws HL7Exception { 1403 return (IS) super.insertRepetition(17, rep); 1404 } 1405 1406 1407 /** 1408 * Inserts a repetition of 1409 * STF-17: "Marital Status" at a specific index 1410 * 1411 * @param rep The repetition index (0-indexed) 1412 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1413 */ 1414 public IS insertStf17_MaritalStatus(int rep) throws HL7Exception { 1415 return (IS) super.insertRepetition(17, rep); 1416 } 1417 1418 1419 /** 1420 * Removes a repetition of 1421 * STF-17: "Marital Status" at a specific index 1422 * 1423 * @param rep The repetition index (0-indexed) 1424 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1425 */ 1426 public IS removeMaritalStatus(int rep) throws HL7Exception { 1427 return (IS) super.removeRepetition(17, rep); 1428 } 1429 1430 1431 /** 1432 * Removes a repetition of 1433 * STF-17: "Marital Status" at a specific index 1434 * 1435 * @param rep The repetition index (0-indexed) 1436 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1437 */ 1438 public IS removeStf17_MaritalStatus(int rep) throws HL7Exception { 1439 return (IS) super.removeRepetition(17, rep); 1440 } 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" - creates it if necessary 1528 */ 1529 public DLN getDriverSLicenseNumber() { 1530 DLN retVal = this.getTypedField(22, 0); 1531 return retVal; 1532 } 1533 1534 /** 1535 * Returns 1536 * STF-22: "Driver's License Number" - creates it if necessary 1537 */ 1538 public DLN getStf22_DriverSLicenseNumber() { 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 CE(getMessage()); 1632 case 2: return new XPN(getMessage()); 1633 case 3: return new ID(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 AD(getMessage()); 1641 case 11: return new CM_DIN(getMessage()); 1642 case 12: return new CM_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 IS(getMessage(), new Integer( 2 )); 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