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