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.v22.segment; 035 036// import ca.uhn.hl7v2.model.v22.group.*; 037import ca.uhn.hl7v2.model.v22.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 STF message segment (staff identification segment). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>STF-1: STF - primary key value (CE) <b> </b> 053 * <li>STF-2: Staff ID Code (CE) <b>optional repeating</b> 054 * <li>STF-3: Staff Name (PN) <b>optional </b> 055 * <li>STF-4: Staff Type (ID) <b>optional repeating</b> 056 * <li>STF-5: Sex (ID) <b>optional </b> 057 * <li>STF-6: Date of Birth (TS) <b>optional </b> 058 * <li>STF-7: Active / inactive (ID) <b>optional </b> 059 * <li>STF-8: Department (CE) <b>optional repeating</b> 060 * <li>STF-9: Service (CE) <b>optional repeating</b> 061 * <li>STF-10: Phone (TN) <b>optional repeating</b> 062 * <li>STF-11: Office / home address (AD) <b>optional repeating</b> 063 * <li>STF-12: Activation Date (CM_DIN) <b>optional repeating</b> 064 * <li>STF-13: Inactivation Date (CM_DIN) <b>optional repeating</b> 065 * <li>STF-14: Backup Person ID (CE) <b>optional repeating</b> 066 * <li>STF-15: E-mail Address (ST) <b>optional repeating</b> 067 * <li>STF-16: Preferred method of Contact (ID) <b>optional </b> 068 * </ul> 069 */ 070@SuppressWarnings("unused") 071public class STF extends AbstractSegment { 072 073 /** 074 * Creates a new STF segment 075 */ 076 public STF(Group parent, ModelClassFactory factory) { 077 super(parent, factory); 078 init(factory); 079 } 080 081 private void init(ModelClassFactory factory) { 082 try { 083 this.add(CE.class, true, 1, 60, new Object[]{ getMessage() }, "STF - primary key value"); 084 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Staff ID Code"); 085 this.add(PN.class, false, 1, 48, new Object[]{ getMessage() }, "Staff Name"); 086 this.add(ID.class, false, 0, 2, new Object[]{ getMessage(), new Integer(182) }, "Staff Type"); 087 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(1) }, "Sex"); 088 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date of Birth"); 089 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(183) }, "Active / inactive"); 090 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Department"); 091 this.add(CE.class, false, 0, 200, new Object[]{ getMessage() }, "Service"); 092 this.add(TN.class, false, 0, 40, new Object[]{ getMessage() }, "Phone"); 093 this.add(AD.class, false, 2, 106, new Object[]{ getMessage() }, "Office / home address"); 094 this.add(CM_DIN.class, false, 0, 19, new Object[]{ getMessage() }, "Activation Date"); 095 this.add(CM_DIN.class, false, 0, 19, new Object[]{ getMessage() }, "Inactivation Date"); 096 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Backup Person ID"); 097 this.add(ST.class, false, 0, 40, new Object[]{ getMessage() }, "E-mail Address"); 098 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(185) }, "Preferred method of Contact"); 099 } catch(HL7Exception e) { 100 log.error("Unexpected error creating STF - this is probably a bug in the source code generator.", e); 101 } 102 } 103 104 105 106 /** 107 * Returns 108 * STF-1: "STF - primary key value" - creates it if necessary 109 */ 110 public CE getSTFPrimaryKeyValue() { 111 CE retVal = this.getTypedField(1, 0); 112 return retVal; 113 } 114 115 /** 116 * Returns 117 * STF-1: "STF - primary key value" - creates it if necessary 118 */ 119 public CE getStf1_STFPrimaryKeyValue() { 120 CE retVal = this.getTypedField(1, 0); 121 return retVal; 122 } 123 124 125 /** 126 * Returns all repetitions of Staff ID Code (STF-2). 127 */ 128 public CE[] getStaffIDCode() { 129 CE[] retVal = this.getTypedField(2, new CE[0]); 130 return retVal; 131 } 132 133 134 /** 135 * Returns all repetitions of Staff ID Code (STF-2). 136 */ 137 public CE[] getStf2_StaffIDCode() { 138 CE[] retVal = this.getTypedField(2, new CE[0]); 139 return retVal; 140 } 141 142 143 /** 144 * Returns a count of the current number of repetitions of Staff ID Code (STF-2). 145 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 146 * it will return zero. 147 */ 148 public int getStaffIDCodeReps() { 149 return this.getReps(2); 150 } 151 152 153 /** 154 * Returns a specific repetition of 155 * STF-2: "Staff ID Code" - creates it if necessary 156 * 157 * @param rep The repetition index (0-indexed) 158 */ 159 public CE getStaffIDCode(int rep) { 160 CE retVal = this.getTypedField(2, rep); 161 return retVal; 162 } 163 164 /** 165 * Returns a specific repetition of 166 * STF-2: "Staff ID Code" - creates it if necessary 167 * 168 * @param rep The repetition index (0-indexed) 169 */ 170 public CE getStf2_StaffIDCode(int rep) { 171 CE retVal = this.getTypedField(2, rep); 172 return retVal; 173 } 174 175 /** 176 * Returns a count of the current number of repetitions of Staff ID Code (STF-2). 177 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 178 * it will return zero. 179 */ 180 public int getStf2_StaffIDCodeReps() { 181 return this.getReps(2); 182 } 183 184 185 /** 186 * Inserts a repetition of 187 * STF-2: "Staff ID Code" at a specific index 188 * 189 * @param rep The repetition index (0-indexed) 190 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 191 */ 192 public CE insertStaffIDCode(int rep) throws HL7Exception { 193 return (CE) super.insertRepetition(2, rep); 194 } 195 196 197 /** 198 * Inserts a repetition of 199 * STF-2: "Staff ID Code" at a specific index 200 * 201 * @param rep The repetition index (0-indexed) 202 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 203 */ 204 public CE insertStf2_StaffIDCode(int rep) throws HL7Exception { 205 return (CE) super.insertRepetition(2, rep); 206 } 207 208 209 /** 210 * Removes a repetition of 211 * STF-2: "Staff ID Code" at a specific index 212 * 213 * @param rep The repetition index (0-indexed) 214 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 215 */ 216 public CE removeStaffIDCode(int rep) throws HL7Exception { 217 return (CE) super.removeRepetition(2, rep); 218 } 219 220 221 /** 222 * Removes a repetition of 223 * STF-2: "Staff ID Code" at a specific index 224 * 225 * @param rep The repetition index (0-indexed) 226 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 227 */ 228 public CE removeStf2_StaffIDCode(int rep) throws HL7Exception { 229 return (CE) super.removeRepetition(2, rep); 230 } 231 232 233 234 235 /** 236 * Returns 237 * STF-3: "Staff Name" - creates it if necessary 238 */ 239 public PN getStaffName() { 240 PN retVal = this.getTypedField(3, 0); 241 return retVal; 242 } 243 244 /** 245 * Returns 246 * STF-3: "Staff Name" - creates it if necessary 247 */ 248 public PN getStf3_StaffName() { 249 PN retVal = this.getTypedField(3, 0); 250 return retVal; 251 } 252 253 254 /** 255 * Returns all repetitions of Staff Type (STF-4). 256 */ 257 public ID[] getStaffType() { 258 ID[] retVal = this.getTypedField(4, new ID[0]); 259 return retVal; 260 } 261 262 263 /** 264 * Returns all repetitions of Staff Type (STF-4). 265 */ 266 public ID[] getStf4_StaffType() { 267 ID[] retVal = this.getTypedField(4, new ID[0]); 268 return retVal; 269 } 270 271 272 /** 273 * Returns a count of the current number of repetitions of Staff Type (STF-4). 274 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 275 * it will return zero. 276 */ 277 public int getStaffTypeReps() { 278 return this.getReps(4); 279 } 280 281 282 /** 283 * Returns a specific repetition of 284 * STF-4: "Staff Type" - creates it if necessary 285 * 286 * @param rep The repetition index (0-indexed) 287 */ 288 public ID getStaffType(int rep) { 289 ID retVal = this.getTypedField(4, rep); 290 return retVal; 291 } 292 293 /** 294 * Returns a specific repetition of 295 * STF-4: "Staff Type" - creates it if necessary 296 * 297 * @param rep The repetition index (0-indexed) 298 */ 299 public ID getStf4_StaffType(int rep) { 300 ID retVal = this.getTypedField(4, rep); 301 return retVal; 302 } 303 304 /** 305 * Returns a count of the current number of repetitions of Staff Type (STF-4). 306 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 307 * it will return zero. 308 */ 309 public int getStf4_StaffTypeReps() { 310 return this.getReps(4); 311 } 312 313 314 /** 315 * Inserts a repetition of 316 * STF-4: "Staff Type" at a specific index 317 * 318 * @param rep The repetition index (0-indexed) 319 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 320 */ 321 public ID insertStaffType(int rep) throws HL7Exception { 322 return (ID) super.insertRepetition(4, rep); 323 } 324 325 326 /** 327 * Inserts a repetition of 328 * STF-4: "Staff Type" at a specific index 329 * 330 * @param rep The repetition index (0-indexed) 331 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 332 */ 333 public ID insertStf4_StaffType(int rep) throws HL7Exception { 334 return (ID) super.insertRepetition(4, rep); 335 } 336 337 338 /** 339 * Removes a repetition of 340 * STF-4: "Staff Type" 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 ID removeStaffType(int rep) throws HL7Exception { 346 return (ID) super.removeRepetition(4, rep); 347 } 348 349 350 /** 351 * Removes a repetition of 352 * STF-4: "Staff Type" 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 ID removeStf4_StaffType(int rep) throws HL7Exception { 358 return (ID) super.removeRepetition(4, rep); 359 } 360 361 362 363 364 /** 365 * Returns 366 * STF-5: "Sex" - creates it if necessary 367 */ 368 public ID getSex() { 369 ID retVal = this.getTypedField(5, 0); 370 return retVal; 371 } 372 373 /** 374 * Returns 375 * STF-5: "Sex" - creates it if necessary 376 */ 377 public ID getStf5_Sex() { 378 ID retVal = this.getTypedField(5, 0); 379 return retVal; 380 } 381 382 383 384 /** 385 * Returns 386 * STF-6: "Date of Birth" - creates it if necessary 387 */ 388 public TS getDateOfBirth() { 389 TS retVal = this.getTypedField(6, 0); 390 return retVal; 391 } 392 393 /** 394 * Returns 395 * STF-6: "Date of Birth" - creates it if necessary 396 */ 397 public TS getStf6_DateOfBirth() { 398 TS retVal = this.getTypedField(6, 0); 399 return retVal; 400 } 401 402 403 404 /** 405 * Returns 406 * STF-7: "Active / inactive" - creates it if necessary 407 */ 408 public ID getActiveInactive() { 409 ID retVal = this.getTypedField(7, 0); 410 return retVal; 411 } 412 413 /** 414 * Returns 415 * STF-7: "Active / inactive" - creates it if necessary 416 */ 417 public ID getStf7_ActiveInactive() { 418 ID retVal = this.getTypedField(7, 0); 419 return retVal; 420 } 421 422 423 /** 424 * Returns all repetitions of Department (STF-8). 425 */ 426 public CE[] getDepartment() { 427 CE[] retVal = this.getTypedField(8, new CE[0]); 428 return retVal; 429 } 430 431 432 /** 433 * Returns all repetitions of Department (STF-8). 434 */ 435 public CE[] getStf8_Department() { 436 CE[] retVal = this.getTypedField(8, new CE[0]); 437 return retVal; 438 } 439 440 441 /** 442 * Returns a count of the current number of repetitions of Department (STF-8). 443 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 444 * it will return zero. 445 */ 446 public int getDepartmentReps() { 447 return this.getReps(8); 448 } 449 450 451 /** 452 * Returns a specific repetition of 453 * STF-8: "Department" - creates it if necessary 454 * 455 * @param rep The repetition index (0-indexed) 456 */ 457 public CE getDepartment(int rep) { 458 CE retVal = this.getTypedField(8, rep); 459 return retVal; 460 } 461 462 /** 463 * Returns a specific repetition of 464 * STF-8: "Department" - creates it if necessary 465 * 466 * @param rep The repetition index (0-indexed) 467 */ 468 public CE getStf8_Department(int rep) { 469 CE retVal = this.getTypedField(8, rep); 470 return retVal; 471 } 472 473 /** 474 * Returns a count of the current number of repetitions of Department (STF-8). 475 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 476 * it will return zero. 477 */ 478 public int getStf8_DepartmentReps() { 479 return this.getReps(8); 480 } 481 482 483 /** 484 * Inserts a repetition of 485 * STF-8: "Department" 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 CE insertDepartment(int rep) throws HL7Exception { 491 return (CE) super.insertRepetition(8, rep); 492 } 493 494 495 /** 496 * Inserts a repetition of 497 * STF-8: "Department" at a specific index 498 * 499 * @param rep The repetition index (0-indexed) 500 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 501 */ 502 public CE insertStf8_Department(int rep) throws HL7Exception { 503 return (CE) super.insertRepetition(8, rep); 504 } 505 506 507 /** 508 * Removes a repetition of 509 * STF-8: "Department" at a specific index 510 * 511 * @param rep The repetition index (0-indexed) 512 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 513 */ 514 public CE removeDepartment(int rep) throws HL7Exception { 515 return (CE) super.removeRepetition(8, rep); 516 } 517 518 519 /** 520 * Removes a repetition of 521 * STF-8: "Department" at a specific index 522 * 523 * @param rep The repetition index (0-indexed) 524 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 525 */ 526 public CE removeStf8_Department(int rep) throws HL7Exception { 527 return (CE) super.removeRepetition(8, rep); 528 } 529 530 531 532 /** 533 * Returns all repetitions of Service (STF-9). 534 */ 535 public CE[] getService() { 536 CE[] retVal = this.getTypedField(9, new CE[0]); 537 return retVal; 538 } 539 540 541 /** 542 * Returns all repetitions of Service (STF-9). 543 */ 544 public CE[] getStf9_Service() { 545 CE[] retVal = this.getTypedField(9, new CE[0]); 546 return retVal; 547 } 548 549 550 /** 551 * Returns a count of the current number of repetitions of Service (STF-9). 552 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 553 * it will return zero. 554 */ 555 public int getServiceReps() { 556 return this.getReps(9); 557 } 558 559 560 /** 561 * Returns a specific repetition of 562 * STF-9: "Service" - creates it if necessary 563 * 564 * @param rep The repetition index (0-indexed) 565 */ 566 public CE getService(int rep) { 567 CE retVal = this.getTypedField(9, rep); 568 return retVal; 569 } 570 571 /** 572 * Returns a specific repetition of 573 * STF-9: "Service" - creates it if necessary 574 * 575 * @param rep The repetition index (0-indexed) 576 */ 577 public CE getStf9_Service(int rep) { 578 CE retVal = this.getTypedField(9, rep); 579 return retVal; 580 } 581 582 /** 583 * Returns a count of the current number of repetitions of Service (STF-9). 584 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 585 * it will return zero. 586 */ 587 public int getStf9_ServiceReps() { 588 return this.getReps(9); 589 } 590 591 592 /** 593 * Inserts a repetition of 594 * STF-9: "Service" at a specific index 595 * 596 * @param rep The repetition index (0-indexed) 597 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 598 */ 599 public CE insertService(int rep) throws HL7Exception { 600 return (CE) super.insertRepetition(9, rep); 601 } 602 603 604 /** 605 * Inserts a repetition of 606 * STF-9: "Service" at a specific index 607 * 608 * @param rep The repetition index (0-indexed) 609 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 610 */ 611 public CE insertStf9_Service(int rep) throws HL7Exception { 612 return (CE) super.insertRepetition(9, rep); 613 } 614 615 616 /** 617 * Removes a repetition of 618 * STF-9: "Service" 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 removeService(int rep) throws HL7Exception { 624 return (CE) super.removeRepetition(9, rep); 625 } 626 627 628 /** 629 * Removes a repetition of 630 * STF-9: "Service" 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 removeStf9_Service(int rep) throws HL7Exception { 636 return (CE) super.removeRepetition(9, rep); 637 } 638 639 640 641 /** 642 * Returns all repetitions of Phone (STF-10). 643 */ 644 public TN[] getPhone() { 645 TN[] retVal = this.getTypedField(10, new TN[0]); 646 return retVal; 647 } 648 649 650 /** 651 * Returns all repetitions of Phone (STF-10). 652 */ 653 public TN[] getStf10_Phone() { 654 TN[] retVal = this.getTypedField(10, new TN[0]); 655 return retVal; 656 } 657 658 659 /** 660 * Returns a count of the current number of repetitions of Phone (STF-10). 661 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 662 * it will return zero. 663 */ 664 public int getPhoneReps() { 665 return this.getReps(10); 666 } 667 668 669 /** 670 * Returns a specific repetition of 671 * STF-10: "Phone" - creates it if necessary 672 * 673 * @param rep The repetition index (0-indexed) 674 */ 675 public TN getPhone(int rep) { 676 TN retVal = this.getTypedField(10, rep); 677 return retVal; 678 } 679 680 /** 681 * Returns a specific repetition of 682 * STF-10: "Phone" - creates it if necessary 683 * 684 * @param rep The repetition index (0-indexed) 685 */ 686 public TN getStf10_Phone(int rep) { 687 TN retVal = this.getTypedField(10, rep); 688 return retVal; 689 } 690 691 /** 692 * Returns a count of the current number of repetitions of Phone (STF-10). 693 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 694 * it will return zero. 695 */ 696 public int getStf10_PhoneReps() { 697 return this.getReps(10); 698 } 699 700 701 /** 702 * Inserts a repetition of 703 * STF-10: "Phone" at a specific index 704 * 705 * @param rep The repetition index (0-indexed) 706 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 707 */ 708 public TN insertPhone(int rep) throws HL7Exception { 709 return (TN) super.insertRepetition(10, rep); 710 } 711 712 713 /** 714 * Inserts a repetition of 715 * STF-10: "Phone" at a specific index 716 * 717 * @param rep The repetition index (0-indexed) 718 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 719 */ 720 public TN insertStf10_Phone(int rep) throws HL7Exception { 721 return (TN) super.insertRepetition(10, rep); 722 } 723 724 725 /** 726 * Removes a repetition of 727 * STF-10: "Phone" 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 TN removePhone(int rep) throws HL7Exception { 733 return (TN) super.removeRepetition(10, rep); 734 } 735 736 737 /** 738 * Removes a repetition of 739 * STF-10: "Phone" 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 TN removeStf10_Phone(int rep) throws HL7Exception { 745 return (TN) super.removeRepetition(10, rep); 746 } 747 748 749 750 /** 751 * Returns all repetitions of Office / home address (STF-11). 752 */ 753 public AD[] getOfficeHomeAddress() { 754 AD[] retVal = this.getTypedField(11, new AD[0]); 755 return retVal; 756 } 757 758 759 /** 760 * Returns all repetitions of Office / home address (STF-11). 761 */ 762 public AD[] getStf11_OfficeHomeAddress() { 763 AD[] retVal = this.getTypedField(11, new AD[0]); 764 return retVal; 765 } 766 767 768 /** 769 * Returns a count of the current number of repetitions of Office / home address (STF-11). 770 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 771 * it will return zero. 772 */ 773 public int getOfficeHomeAddressReps() { 774 return this.getReps(11); 775 } 776 777 778 /** 779 * Returns a specific repetition of 780 * STF-11: "Office / home address" - creates it if necessary 781 * 782 * @param rep The repetition index (0-indexed) 783 */ 784 public AD getOfficeHomeAddress(int rep) { 785 AD retVal = this.getTypedField(11, rep); 786 return retVal; 787 } 788 789 /** 790 * Returns a specific repetition of 791 * STF-11: "Office / home address" - creates it if necessary 792 * 793 * @param rep The repetition index (0-indexed) 794 */ 795 public AD getStf11_OfficeHomeAddress(int rep) { 796 AD retVal = this.getTypedField(11, rep); 797 return retVal; 798 } 799 800 /** 801 * Returns a count of the current number of repetitions of Office / home address (STF-11). 802 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 803 * it will return zero. 804 */ 805 public int getStf11_OfficeHomeAddressReps() { 806 return this.getReps(11); 807 } 808 809 810 /** 811 * Inserts a repetition of 812 * STF-11: "Office / home address" at a specific index 813 * 814 * @param rep The repetition index (0-indexed) 815 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 816 */ 817 public AD insertOfficeHomeAddress(int rep) throws HL7Exception { 818 return (AD) super.insertRepetition(11, rep); 819 } 820 821 822 /** 823 * Inserts a repetition of 824 * STF-11: "Office / home address" at a specific index 825 * 826 * @param rep The repetition index (0-indexed) 827 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 828 */ 829 public AD insertStf11_OfficeHomeAddress(int rep) throws HL7Exception { 830 return (AD) super.insertRepetition(11, rep); 831 } 832 833 834 /** 835 * Removes a repetition of 836 * STF-11: "Office / home address" 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 AD removeOfficeHomeAddress(int rep) throws HL7Exception { 842 return (AD) super.removeRepetition(11, rep); 843 } 844 845 846 /** 847 * Removes a repetition of 848 * STF-11: "Office / home address" 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 AD removeStf11_OfficeHomeAddress(int rep) throws HL7Exception { 854 return (AD) super.removeRepetition(11, rep); 855 } 856 857 858 859 /** 860 * Returns all repetitions of Activation Date (STF-12). 861 */ 862 public CM_DIN[] getActivationDate() { 863 CM_DIN[] retVal = this.getTypedField(12, new CM_DIN[0]); 864 return retVal; 865 } 866 867 868 /** 869 * Returns all repetitions of Activation Date (STF-12). 870 */ 871 public CM_DIN[] getStf12_ActivationDate() { 872 CM_DIN[] retVal = this.getTypedField(12, new CM_DIN[0]); 873 return retVal; 874 } 875 876 877 /** 878 * Returns a count of the current number of repetitions of Activation Date (STF-12). 879 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 880 * it will return zero. 881 */ 882 public int getActivationDateReps() { 883 return this.getReps(12); 884 } 885 886 887 /** 888 * Returns a specific repetition of 889 * STF-12: "Activation Date" - creates it if necessary 890 * 891 * @param rep The repetition index (0-indexed) 892 */ 893 public CM_DIN getActivationDate(int rep) { 894 CM_DIN retVal = this.getTypedField(12, rep); 895 return retVal; 896 } 897 898 /** 899 * Returns a specific repetition of 900 * STF-12: "Activation Date" - creates it if necessary 901 * 902 * @param rep The repetition index (0-indexed) 903 */ 904 public CM_DIN getStf12_ActivationDate(int rep) { 905 CM_DIN retVal = this.getTypedField(12, rep); 906 return retVal; 907 } 908 909 /** 910 * Returns a count of the current number of repetitions of Activation Date (STF-12). 911 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 912 * it will return zero. 913 */ 914 public int getStf12_ActivationDateReps() { 915 return this.getReps(12); 916 } 917 918 919 /** 920 * Inserts a repetition of 921 * STF-12: "Activation Date" at a specific index 922 * 923 * @param rep The repetition index (0-indexed) 924 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 925 */ 926 public CM_DIN insertActivationDate(int rep) throws HL7Exception { 927 return (CM_DIN) super.insertRepetition(12, rep); 928 } 929 930 931 /** 932 * Inserts a repetition of 933 * STF-12: "Activation Date" at a specific index 934 * 935 * @param rep The repetition index (0-indexed) 936 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 937 */ 938 public CM_DIN insertStf12_ActivationDate(int rep) throws HL7Exception { 939 return (CM_DIN) super.insertRepetition(12, rep); 940 } 941 942 943 /** 944 * Removes a repetition of 945 * STF-12: "Activation Date" 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 CM_DIN removeActivationDate(int rep) throws HL7Exception { 951 return (CM_DIN) super.removeRepetition(12, rep); 952 } 953 954 955 /** 956 * Removes a repetition of 957 * STF-12: "Activation Date" 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 CM_DIN removeStf12_ActivationDate(int rep) throws HL7Exception { 963 return (CM_DIN) super.removeRepetition(12, rep); 964 } 965 966 967 968 /** 969 * Returns all repetitions of Inactivation Date (STF-13). 970 */ 971 public CM_DIN[] getInactivationDate() { 972 CM_DIN[] retVal = this.getTypedField(13, new CM_DIN[0]); 973 return retVal; 974 } 975 976 977 /** 978 * Returns all repetitions of Inactivation Date (STF-13). 979 */ 980 public CM_DIN[] getStf13_InactivationDate() { 981 CM_DIN[] retVal = this.getTypedField(13, new CM_DIN[0]); 982 return retVal; 983 } 984 985 986 /** 987 * Returns a count of the current number of repetitions of Inactivation Date (STF-13). 988 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 989 * it will return zero. 990 */ 991 public int getInactivationDateReps() { 992 return this.getReps(13); 993 } 994 995 996 /** 997 * Returns a specific repetition of 998 * STF-13: "Inactivation Date" - creates it if necessary 999 * 1000 * @param rep The repetition index (0-indexed) 1001 */ 1002 public CM_DIN getInactivationDate(int rep) { 1003 CM_DIN retVal = this.getTypedField(13, rep); 1004 return retVal; 1005 } 1006 1007 /** 1008 * Returns a specific repetition of 1009 * STF-13: "Inactivation Date" - creates it if necessary 1010 * 1011 * @param rep The repetition index (0-indexed) 1012 */ 1013 public CM_DIN getStf13_InactivationDate(int rep) { 1014 CM_DIN retVal = this.getTypedField(13, rep); 1015 return retVal; 1016 } 1017 1018 /** 1019 * Returns a count of the current number of repetitions of Inactivation Date (STF-13). 1020 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1021 * it will return zero. 1022 */ 1023 public int getStf13_InactivationDateReps() { 1024 return this.getReps(13); 1025 } 1026 1027 1028 /** 1029 * Inserts a repetition of 1030 * STF-13: "Inactivation Date" at a specific index 1031 * 1032 * @param rep The repetition index (0-indexed) 1033 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1034 */ 1035 public CM_DIN insertInactivationDate(int rep) throws HL7Exception { 1036 return (CM_DIN) super.insertRepetition(13, rep); 1037 } 1038 1039 1040 /** 1041 * Inserts a repetition of 1042 * STF-13: "Inactivation Date" at a specific index 1043 * 1044 * @param rep The repetition index (0-indexed) 1045 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1046 */ 1047 public CM_DIN insertStf13_InactivationDate(int rep) throws HL7Exception { 1048 return (CM_DIN) super.insertRepetition(13, rep); 1049 } 1050 1051 1052 /** 1053 * Removes a repetition of 1054 * STF-13: "Inactivation 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 CM_DIN removeInactivationDate(int rep) throws HL7Exception { 1060 return (CM_DIN) super.removeRepetition(13, rep); 1061 } 1062 1063 1064 /** 1065 * Removes a repetition of 1066 * STF-13: "Inactivation 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 CM_DIN removeStf13_InactivationDate(int rep) throws HL7Exception { 1072 return (CM_DIN) super.removeRepetition(13, rep); 1073 } 1074 1075 1076 1077 /** 1078 * Returns all repetitions of Backup Person ID (STF-14). 1079 */ 1080 public CE[] getBackupPersonID() { 1081 CE[] retVal = this.getTypedField(14, new CE[0]); 1082 return retVal; 1083 } 1084 1085 1086 /** 1087 * Returns all repetitions of Backup Person ID (STF-14). 1088 */ 1089 public CE[] getStf14_BackupPersonID() { 1090 CE[] retVal = this.getTypedField(14, new CE[0]); 1091 return retVal; 1092 } 1093 1094 1095 /** 1096 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1097 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1098 * it will return zero. 1099 */ 1100 public int getBackupPersonIDReps() { 1101 return this.getReps(14); 1102 } 1103 1104 1105 /** 1106 * Returns a specific repetition of 1107 * STF-14: "Backup Person ID" - creates it if necessary 1108 * 1109 * @param rep The repetition index (0-indexed) 1110 */ 1111 public CE getBackupPersonID(int rep) { 1112 CE retVal = this.getTypedField(14, rep); 1113 return retVal; 1114 } 1115 1116 /** 1117 * Returns a specific repetition of 1118 * STF-14: "Backup Person ID" - creates it if necessary 1119 * 1120 * @param rep The repetition index (0-indexed) 1121 */ 1122 public CE getStf14_BackupPersonID(int rep) { 1123 CE retVal = this.getTypedField(14, rep); 1124 return retVal; 1125 } 1126 1127 /** 1128 * Returns a count of the current number of repetitions of Backup Person ID (STF-14). 1129 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1130 * it will return zero. 1131 */ 1132 public int getStf14_BackupPersonIDReps() { 1133 return this.getReps(14); 1134 } 1135 1136 1137 /** 1138 * Inserts a repetition of 1139 * STF-14: "Backup Person ID" at a specific index 1140 * 1141 * @param rep The repetition index (0-indexed) 1142 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1143 */ 1144 public CE insertBackupPersonID(int rep) throws HL7Exception { 1145 return (CE) super.insertRepetition(14, rep); 1146 } 1147 1148 1149 /** 1150 * Inserts a repetition of 1151 * STF-14: "Backup Person ID" at a specific index 1152 * 1153 * @param rep The repetition index (0-indexed) 1154 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1155 */ 1156 public CE insertStf14_BackupPersonID(int rep) throws HL7Exception { 1157 return (CE) super.insertRepetition(14, rep); 1158 } 1159 1160 1161 /** 1162 * Removes a repetition of 1163 * STF-14: "Backup Person ID" 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 CE removeBackupPersonID(int rep) throws HL7Exception { 1169 return (CE) super.removeRepetition(14, rep); 1170 } 1171 1172 1173 /** 1174 * Removes a repetition of 1175 * STF-14: "Backup Person ID" 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 CE removeStf14_BackupPersonID(int rep) throws HL7Exception { 1181 return (CE) super.removeRepetition(14, rep); 1182 } 1183 1184 1185 1186 /** 1187 * Returns all repetitions of E-mail Address (STF-15). 1188 */ 1189 public ST[] getEMailAddress() { 1190 ST[] retVal = this.getTypedField(15, new ST[0]); 1191 return retVal; 1192 } 1193 1194 1195 /** 1196 * Returns all repetitions of E-mail Address (STF-15). 1197 */ 1198 public ST[] getStf15_EMailAddress() { 1199 ST[] retVal = this.getTypedField(15, new ST[0]); 1200 return retVal; 1201 } 1202 1203 1204 /** 1205 * Returns a count of the current number of repetitions of E-mail Address (STF-15). 1206 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1207 * it will return zero. 1208 */ 1209 public int getEMailAddressReps() { 1210 return this.getReps(15); 1211 } 1212 1213 1214 /** 1215 * Returns a specific repetition of 1216 * STF-15: "E-mail Address" - creates it if necessary 1217 * 1218 * @param rep The repetition index (0-indexed) 1219 */ 1220 public ST getEMailAddress(int rep) { 1221 ST retVal = this.getTypedField(15, rep); 1222 return retVal; 1223 } 1224 1225 /** 1226 * Returns a specific repetition of 1227 * STF-15: "E-mail Address" - creates it if necessary 1228 * 1229 * @param rep The repetition index (0-indexed) 1230 */ 1231 public ST getStf15_EMailAddress(int rep) { 1232 ST retVal = this.getTypedField(15, rep); 1233 return retVal; 1234 } 1235 1236 /** 1237 * Returns a count of the current number of repetitions of E-mail Address (STF-15). 1238 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1239 * it will return zero. 1240 */ 1241 public int getStf15_EMailAddressReps() { 1242 return this.getReps(15); 1243 } 1244 1245 1246 /** 1247 * Inserts a repetition of 1248 * STF-15: "E-mail Address" at a specific index 1249 * 1250 * @param rep The repetition index (0-indexed) 1251 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1252 */ 1253 public ST insertEMailAddress(int rep) throws HL7Exception { 1254 return (ST) super.insertRepetition(15, rep); 1255 } 1256 1257 1258 /** 1259 * Inserts a repetition of 1260 * STF-15: "E-mail Address" at a specific index 1261 * 1262 * @param rep The repetition index (0-indexed) 1263 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1264 */ 1265 public ST insertStf15_EMailAddress(int rep) throws HL7Exception { 1266 return (ST) super.insertRepetition(15, rep); 1267 } 1268 1269 1270 /** 1271 * Removes a repetition of 1272 * STF-15: "E-mail Address" 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 ST removeEMailAddress(int rep) throws HL7Exception { 1278 return (ST) super.removeRepetition(15, rep); 1279 } 1280 1281 1282 /** 1283 * Removes a repetition of 1284 * STF-15: "E-mail Address" 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 ST removeStf15_EMailAddress(int rep) throws HL7Exception { 1290 return (ST) super.removeRepetition(15, rep); 1291 } 1292 1293 1294 1295 1296 /** 1297 * Returns 1298 * STF-16: "Preferred method of Contact" - creates it if necessary 1299 */ 1300 public ID getPreferredMethodOfContact() { 1301 ID retVal = this.getTypedField(16, 0); 1302 return retVal; 1303 } 1304 1305 /** 1306 * Returns 1307 * STF-16: "Preferred method of Contact" - creates it if necessary 1308 */ 1309 public ID getStf16_PreferredMethodOfContact() { 1310 ID retVal = this.getTypedField(16, 0); 1311 return retVal; 1312 } 1313 1314 1315 1316 1317 1318 /** {@inheritDoc} */ 1319 protected Type createNewTypeWithoutReflection(int field) { 1320 switch (field) { 1321 case 0: return new CE(getMessage()); 1322 case 1: return new CE(getMessage()); 1323 case 2: return new PN(getMessage()); 1324 case 3: return new ID(getMessage(), new Integer( 182 )); 1325 case 4: return new ID(getMessage(), new Integer( 1 )); 1326 case 5: return new TS(getMessage()); 1327 case 6: return new ID(getMessage(), new Integer( 183 )); 1328 case 7: return new CE(getMessage()); 1329 case 8: return new CE(getMessage()); 1330 case 9: return new TN(getMessage()); 1331 case 10: return new AD(getMessage()); 1332 case 11: return new CM_DIN(getMessage()); 1333 case 12: return new CM_DIN(getMessage()); 1334 case 13: return new CE(getMessage()); 1335 case 14: return new ST(getMessage()); 1336 case 15: return new ID(getMessage(), new Integer( 185 )); 1337 default: return null; 1338 } 1339 } 1340 1341 1342} 1343