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