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