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