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