1 /* 2 * This class is an auto-generated source file for a HAPI 3 * HL7 v2.x standard structure class. 4 * 5 * For more information, visit: http://hl7api.sourceforge.net/ 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 1.1 8 * (the "License"); you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 12 * specific language governing rights and limitations under the License. 13 * 14 * The Original Code is "[file_name]". Description: 15 * "[one_line_description]" 16 * 17 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 18 * 2012. All Rights Reserved. 19 * 20 * Contributor(s): ______________________________________. 21 * 22 * Alternatively, the contents of this file may be used under the terms of the 23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 24 * applicable instead of those above. If you wish to allow use of your version of this 25 * file only under the terms of the GPL and not to allow others to use your version 26 * of this file under the MPL, indicate your decision by deleting the provisions above 27 * and replace them with the notice and other provisions required by the GPL License. 28 * If you do not delete the provisions above, a recipient may use your version of 29 * this file under either the MPL or the GPL. 30 * 31 */ 32 33 34 package ca.uhn.hl7v2.test.singledt.conf.segment; 35 36 // import ca.uhn.hl7v2.test.singledt.conf.group.*; 37 import ca.uhn.hl7v2.model.v25.datatype.*; 38 import ca.uhn.hl7v2.HL7Exception; 39 import ca.uhn.hl7v2.parser.ModelClassFactory; 40 import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 41 import ca.uhn.hl7v2.model.AbstractMessage; 42 import ca.uhn.hl7v2.model.Group; 43 import ca.uhn.hl7v2.model.Type; 44 import ca.uhn.hl7v2.model.AbstractSegment; 45 import ca.uhn.hl7v2.model.Varies; 46 47 48 /** 49 *<p>Represents an HL7 DG1 message segment (Diagnosis). 50 * This segment has the following fields:</p> 51 * <ul> 52 * <li>DG1-1: Set ID - DG1 (SI) <b> </b> 53 * <li>DG1-2: Diagnosis Coding Method (ID) <b>optional </b> 54 * <li>DG1-3: Diagnosis Code - DG1 (CE) <b>optional </b> 55 * <li>DG1-4: Diagnosis Description (ST) <b>optional repeating</b> 56 * <li>DG1-5: Diagnosis Date/Time (TS) <b>optional </b> 57 * <li>DG1-6: Diagnosis Type (IS) <b> </b> 58 * <li>DG1-7: Major Diagnostic Category (CE) <b>optional repeating</b> 59 * <li>DG1-8: Diagnostic Related Group (CE) <b>optional repeating</b> 60 * <li>DG1-9: DRG Approval Indicator (ID) <b>optional repeating</b> 61 * <li>DG1-10: DRG Grouper Review Code (IS) <b>optional repeating</b> 62 * <li>DG1-11: Outlier Type (CE) <b>optional repeating</b> 63 * <li>DG1-12: Outlier Days (NM) <b>optional repeating</b> 64 * <li>DG1-13: Outlier Cost (CP) <b>optional repeating</b> 65 * <li>DG1-14: Grouper Version And Type (ST) <b>optional repeating</b> 66 * <li>DG1-15: Diagnosis Priority (ID) <b>optional </b> 67 * <li>DG1-16: Diagnosing Clinician (XCN) <b>optional repeating</b> 68 * <li>DG1-17: Diagnosis Classification (IS) <b>optional </b> 69 * <li>DG1-18: Confidential Indicator (ID) <b>optional </b> 70 * <li>DG1-19: Attestation Date/Time (TS) <b>optional </b> 71 * <li>DG1-20: Diagnosis Identifier (EI) <b>optional </b> 72 * <li>DG1-21: Diagnosis Action Code (ID) <b>optional </b> 73 * </ul> 74 */ 75 @SuppressWarnings("unused") 76 public class DG1 extends AbstractSegment { 77 78 /** 79 * Creates a new DG1 segment 80 */ 81 public DG1(Group parent, ModelClassFactory factory) { 82 super(parent, factory); 83 init(factory); 84 } 85 86 private void init(ModelClassFactory factory) { 87 try { 88 this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - DG1"); 89 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(53) }, "Diagnosis Coding Method"); 90 this.add(CE.class, false, 1, 478, new Object[]{ getMessage() }, "Diagnosis Code - DG1"); 91 this.add(ST.class, false, -1, 40, new Object[]{ getMessage() }, "Diagnosis Description"); 92 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Diagnosis Date/Time"); 93 this.add(IS.class, true, 1, 2, new Object[]{ getMessage(), new Integer(52) }, "Diagnosis Type"); 94 this.add(CE.class, false, -1, 478, new Object[]{ getMessage() }, "Major Diagnostic Category"); 95 this.add(CE.class, false, -1, 478, new Object[]{ getMessage() }, "Diagnostic Related Group"); 96 this.add(ID.class, false, -1, 1, new Object[]{ getMessage(), new Integer(136) }, "DRG Approval Indicator"); 97 this.add(IS.class, false, -1, 2, new Object[]{ getMessage(), new Integer(56) }, "DRG Grouper Review Code"); 98 this.add(CE.class, false, -1, 478, new Object[]{ getMessage() }, "Outlier Type"); 99 this.add(NM.class, false, -1, 3, new Object[]{ getMessage() }, "Outlier Days"); 100 this.add(CP.class, false, -1, 538, new Object[]{ getMessage() }, "Outlier Cost"); 101 this.add(ST.class, false, -1, 4, new Object[]{ getMessage() }, "Grouper Version And Type"); 102 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(359) }, "Diagnosis Priority"); 103 this.add(XCN.class, false, -1, 309, new Object[]{ getMessage() }, "Diagnosing Clinician"); 104 this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(228) }, "Diagnosis Classification"); 105 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Confidential Indicator"); 106 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Attestation Date/Time"); 107 this.add(EI.class, false, 1, 427, new Object[]{ getMessage() }, "Diagnosis Identifier"); 108 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(206) }, "Diagnosis Action Code"); 109 } catch(HL7Exception e) { 110 log.error("Unexpected error creating DG1 - this is probably a bug in the source code generator.", e); 111 } 112 } 113 114 115 116 /** 117 * Returns 118 * DG1-1: "Set ID - DG1" - creates it if necessary 119 */ 120 public SI getSetIDDG1() { 121 SI retVal = this.getTypedField(1, 0); 122 return retVal; 123 } 124 125 /** 126 * Returns 127 * DG1-1: "Set ID - DG1" - creates it if necessary 128 */ 129 public SI getDg11_SetIDDG1() { 130 SI retVal = this.getTypedField(1, 0); 131 return retVal; 132 } 133 134 135 136 /** 137 * Returns 138 * DG1-2: "Diagnosis Coding Method" - creates it if necessary 139 */ 140 public ID getDiagnosisCodingMethod() { 141 ID retVal = this.getTypedField(2, 0); 142 return retVal; 143 } 144 145 /** 146 * Returns 147 * DG1-2: "Diagnosis Coding Method" - creates it if necessary 148 */ 149 public ID getDg12_DiagnosisCodingMethod() { 150 ID retVal = this.getTypedField(2, 0); 151 return retVal; 152 } 153 154 155 156 /** 157 * Returns 158 * DG1-3: "Diagnosis Code - DG1" - creates it if necessary 159 */ 160 public CE getDiagnosisCodeDG1() { 161 CE retVal = this.getTypedField(3, 0); 162 return retVal; 163 } 164 165 /** 166 * Returns 167 * DG1-3: "Diagnosis Code - DG1" - creates it if necessary 168 */ 169 public CE getDg13_DiagnosisCodeDG1() { 170 CE retVal = this.getTypedField(3, 0); 171 return retVal; 172 } 173 174 175 /** 176 * Returns all repetitions of Diagnosis Description (DG1-4). 177 */ 178 public ST[] getDiagnosisDescription() { 179 ST[] retVal = this.getTypedField(4, new ST[0]); 180 return retVal; 181 } 182 183 184 /** 185 * Returns all repetitions of Diagnosis Description (DG1-4). 186 */ 187 public ST[] getDg14_DiagnosisDescription() { 188 ST[] retVal = this.getTypedField(4, new ST[0]); 189 return retVal; 190 } 191 192 193 /** 194 * Returns a count of the current number of repetitions of Diagnosis Description (DG1-4). 195 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 196 * it will return zero. 197 */ 198 public int getDiagnosisDescriptionReps() { 199 return this.getReps(4); 200 } 201 202 203 /** 204 * Returns a specific repetition of 205 * DG1-4: "Diagnosis Description" - creates it if necessary 206 * 207 * @param rep The repetition index (0-indexed) 208 */ 209 public ST getDiagnosisDescription(int rep) { 210 ST retVal = this.getTypedField(4, rep); 211 return retVal; 212 } 213 214 /** 215 * Returns a specific repetition of 216 * DG1-4: "Diagnosis Description" - creates it if necessary 217 * 218 * @param rep The repetition index (0-indexed) 219 */ 220 public ST getDg14_DiagnosisDescription(int rep) { 221 ST retVal = this.getTypedField(4, rep); 222 return retVal; 223 } 224 225 /** 226 * Returns a count of the current number of repetitions of Diagnosis Description (DG1-4). 227 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 228 * it will return zero. 229 */ 230 public int getDg14_DiagnosisDescriptionReps() { 231 return this.getReps(4); 232 } 233 234 235 /** 236 * Inserts a repetition of 237 * DG1-4: "Diagnosis Description" at a specific index 238 * 239 * @param rep The repetition index (0-indexed) 240 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 241 */ 242 public ST insertDiagnosisDescription(int rep) throws HL7Exception { 243 return (ST) super.insertRepetition(4, rep); 244 } 245 246 247 /** 248 * Inserts a repetition of 249 * DG1-4: "Diagnosis Description" at a specific index 250 * 251 * @param rep The repetition index (0-indexed) 252 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 253 */ 254 public ST insertDg14_DiagnosisDescription(int rep) throws HL7Exception { 255 return (ST) super.insertRepetition(4, rep); 256 } 257 258 259 /** 260 * Removes a repetition of 261 * DG1-4: "Diagnosis Description" at a specific index 262 * 263 * @param rep The repetition index (0-indexed) 264 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 265 */ 266 public ST removeDiagnosisDescription(int rep) throws HL7Exception { 267 return (ST) super.removeRepetition(4, rep); 268 } 269 270 271 /** 272 * Removes a repetition of 273 * DG1-4: "Diagnosis Description" at a specific index 274 * 275 * @param rep The repetition index (0-indexed) 276 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 277 */ 278 public ST removeDg14_DiagnosisDescription(int rep) throws HL7Exception { 279 return (ST) super.removeRepetition(4, rep); 280 } 281 282 283 284 285 /** 286 * Returns 287 * DG1-5: "Diagnosis Date/Time" - creates it if necessary 288 */ 289 public TS getDiagnosisDateTime() { 290 TS retVal = this.getTypedField(5, 0); 291 return retVal; 292 } 293 294 /** 295 * Returns 296 * DG1-5: "Diagnosis Date/Time" - creates it if necessary 297 */ 298 public TS getDg15_DiagnosisDateTime() { 299 TS retVal = this.getTypedField(5, 0); 300 return retVal; 301 } 302 303 304 305 /** 306 * Returns 307 * DG1-6: "Diagnosis Type" - creates it if necessary 308 */ 309 public IS getDiagnosisType() { 310 IS retVal = this.getTypedField(6, 0); 311 return retVal; 312 } 313 314 /** 315 * Returns 316 * DG1-6: "Diagnosis Type" - creates it if necessary 317 */ 318 public IS getDg16_DiagnosisType() { 319 IS retVal = this.getTypedField(6, 0); 320 return retVal; 321 } 322 323 324 /** 325 * Returns all repetitions of Major Diagnostic Category (DG1-7). 326 */ 327 public CE[] getMajorDiagnosticCategory() { 328 CE[] retVal = this.getTypedField(7, new CE[0]); 329 return retVal; 330 } 331 332 333 /** 334 * Returns all repetitions of Major Diagnostic Category (DG1-7). 335 */ 336 public CE[] getDg17_MajorDiagnosticCategory() { 337 CE[] retVal = this.getTypedField(7, new CE[0]); 338 return retVal; 339 } 340 341 342 /** 343 * Returns a count of the current number of repetitions of Major Diagnostic Category (DG1-7). 344 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 345 * it will return zero. 346 */ 347 public int getMajorDiagnosticCategoryReps() { 348 return this.getReps(7); 349 } 350 351 352 /** 353 * Returns a specific repetition of 354 * DG1-7: "Major Diagnostic Category" - creates it if necessary 355 * 356 * @param rep The repetition index (0-indexed) 357 */ 358 public CE getMajorDiagnosticCategory(int rep) { 359 CE retVal = this.getTypedField(7, rep); 360 return retVal; 361 } 362 363 /** 364 * Returns a specific repetition of 365 * DG1-7: "Major Diagnostic Category" - creates it if necessary 366 * 367 * @param rep The repetition index (0-indexed) 368 */ 369 public CE getDg17_MajorDiagnosticCategory(int rep) { 370 CE retVal = this.getTypedField(7, rep); 371 return retVal; 372 } 373 374 /** 375 * Returns a count of the current number of repetitions of Major Diagnostic Category (DG1-7). 376 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 377 * it will return zero. 378 */ 379 public int getDg17_MajorDiagnosticCategoryReps() { 380 return this.getReps(7); 381 } 382 383 384 /** 385 * Inserts a repetition of 386 * DG1-7: "Major Diagnostic Category" at a specific index 387 * 388 * @param rep The repetition index (0-indexed) 389 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 390 */ 391 public CE insertMajorDiagnosticCategory(int rep) throws HL7Exception { 392 return (CE) super.insertRepetition(7, rep); 393 } 394 395 396 /** 397 * Inserts a repetition of 398 * DG1-7: "Major Diagnostic Category" at a specific index 399 * 400 * @param rep The repetition index (0-indexed) 401 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 402 */ 403 public CE insertDg17_MajorDiagnosticCategory(int rep) throws HL7Exception { 404 return (CE) super.insertRepetition(7, rep); 405 } 406 407 408 /** 409 * Removes a repetition of 410 * DG1-7: "Major Diagnostic Category" at a specific index 411 * 412 * @param rep The repetition index (0-indexed) 413 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 414 */ 415 public CE removeMajorDiagnosticCategory(int rep) throws HL7Exception { 416 return (CE) super.removeRepetition(7, rep); 417 } 418 419 420 /** 421 * Removes a repetition of 422 * DG1-7: "Major Diagnostic Category" at a specific index 423 * 424 * @param rep The repetition index (0-indexed) 425 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 426 */ 427 public CE removeDg17_MajorDiagnosticCategory(int rep) throws HL7Exception { 428 return (CE) super.removeRepetition(7, rep); 429 } 430 431 432 433 /** 434 * Returns all repetitions of Diagnostic Related Group (DG1-8). 435 */ 436 public CE[] getDiagnosticRelatedGroup() { 437 CE[] retVal = this.getTypedField(8, new CE[0]); 438 return retVal; 439 } 440 441 442 /** 443 * Returns all repetitions of Diagnostic Related Group (DG1-8). 444 */ 445 public CE[] getDg18_DiagnosticRelatedGroup() { 446 CE[] retVal = this.getTypedField(8, new CE[0]); 447 return retVal; 448 } 449 450 451 /** 452 * Returns a count of the current number of repetitions of Diagnostic Related Group (DG1-8). 453 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 454 * it will return zero. 455 */ 456 public int getDiagnosticRelatedGroupReps() { 457 return this.getReps(8); 458 } 459 460 461 /** 462 * Returns a specific repetition of 463 * DG1-8: "Diagnostic Related Group" - creates it if necessary 464 * 465 * @param rep The repetition index (0-indexed) 466 */ 467 public CE getDiagnosticRelatedGroup(int rep) { 468 CE retVal = this.getTypedField(8, rep); 469 return retVal; 470 } 471 472 /** 473 * Returns a specific repetition of 474 * DG1-8: "Diagnostic Related Group" - creates it if necessary 475 * 476 * @param rep The repetition index (0-indexed) 477 */ 478 public CE getDg18_DiagnosticRelatedGroup(int rep) { 479 CE retVal = this.getTypedField(8, rep); 480 return retVal; 481 } 482 483 /** 484 * Returns a count of the current number of repetitions of Diagnostic Related Group (DG1-8). 485 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 486 * it will return zero. 487 */ 488 public int getDg18_DiagnosticRelatedGroupReps() { 489 return this.getReps(8); 490 } 491 492 493 /** 494 * Inserts a repetition of 495 * DG1-8: "Diagnostic Related Group" at a specific index 496 * 497 * @param rep The repetition index (0-indexed) 498 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 499 */ 500 public CE insertDiagnosticRelatedGroup(int rep) throws HL7Exception { 501 return (CE) super.insertRepetition(8, rep); 502 } 503 504 505 /** 506 * Inserts a repetition of 507 * DG1-8: "Diagnostic Related Group" at a specific index 508 * 509 * @param rep The repetition index (0-indexed) 510 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 511 */ 512 public CE insertDg18_DiagnosticRelatedGroup(int rep) throws HL7Exception { 513 return (CE) super.insertRepetition(8, rep); 514 } 515 516 517 /** 518 * Removes a repetition of 519 * DG1-8: "Diagnostic Related Group" at a specific index 520 * 521 * @param rep The repetition index (0-indexed) 522 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 523 */ 524 public CE removeDiagnosticRelatedGroup(int rep) throws HL7Exception { 525 return (CE) super.removeRepetition(8, rep); 526 } 527 528 529 /** 530 * Removes a repetition of 531 * DG1-8: "Diagnostic Related Group" at a specific index 532 * 533 * @param rep The repetition index (0-indexed) 534 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 535 */ 536 public CE removeDg18_DiagnosticRelatedGroup(int rep) throws HL7Exception { 537 return (CE) super.removeRepetition(8, rep); 538 } 539 540 541 542 /** 543 * Returns all repetitions of DRG Approval Indicator (DG1-9). 544 */ 545 public ID[] getDRGApprovalIndicator() { 546 ID[] retVal = this.getTypedField(9, new ID[0]); 547 return retVal; 548 } 549 550 551 /** 552 * Returns all repetitions of DRG Approval Indicator (DG1-9). 553 */ 554 public ID[] getDg19_DRGApprovalIndicator() { 555 ID[] retVal = this.getTypedField(9, new ID[0]); 556 return retVal; 557 } 558 559 560 /** 561 * Returns a count of the current number of repetitions of DRG Approval Indicator (DG1-9). 562 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 563 * it will return zero. 564 */ 565 public int getDRGApprovalIndicatorReps() { 566 return this.getReps(9); 567 } 568 569 570 /** 571 * Returns a specific repetition of 572 * DG1-9: "DRG Approval Indicator" - creates it if necessary 573 * 574 * @param rep The repetition index (0-indexed) 575 */ 576 public ID getDRGApprovalIndicator(int rep) { 577 ID retVal = this.getTypedField(9, rep); 578 return retVal; 579 } 580 581 /** 582 * Returns a specific repetition of 583 * DG1-9: "DRG Approval Indicator" - creates it if necessary 584 * 585 * @param rep The repetition index (0-indexed) 586 */ 587 public ID getDg19_DRGApprovalIndicator(int rep) { 588 ID retVal = this.getTypedField(9, rep); 589 return retVal; 590 } 591 592 /** 593 * Returns a count of the current number of repetitions of DRG Approval Indicator (DG1-9). 594 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 595 * it will return zero. 596 */ 597 public int getDg19_DRGApprovalIndicatorReps() { 598 return this.getReps(9); 599 } 600 601 602 /** 603 * Inserts a repetition of 604 * DG1-9: "DRG Approval Indicator" at a specific index 605 * 606 * @param rep The repetition index (0-indexed) 607 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 608 */ 609 public ID insertDRGApprovalIndicator(int rep) throws HL7Exception { 610 return (ID) super.insertRepetition(9, rep); 611 } 612 613 614 /** 615 * Inserts a repetition of 616 * DG1-9: "DRG Approval Indicator" at a specific index 617 * 618 * @param rep The repetition index (0-indexed) 619 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 620 */ 621 public ID insertDg19_DRGApprovalIndicator(int rep) throws HL7Exception { 622 return (ID) super.insertRepetition(9, rep); 623 } 624 625 626 /** 627 * Removes a repetition of 628 * DG1-9: "DRG Approval Indicator" at a specific index 629 * 630 * @param rep The repetition index (0-indexed) 631 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 632 */ 633 public ID removeDRGApprovalIndicator(int rep) throws HL7Exception { 634 return (ID) super.removeRepetition(9, rep); 635 } 636 637 638 /** 639 * Removes a repetition of 640 * DG1-9: "DRG Approval Indicator" at a specific index 641 * 642 * @param rep The repetition index (0-indexed) 643 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 644 */ 645 public ID removeDg19_DRGApprovalIndicator(int rep) throws HL7Exception { 646 return (ID) super.removeRepetition(9, rep); 647 } 648 649 650 651 /** 652 * Returns all repetitions of DRG Grouper Review Code (DG1-10). 653 */ 654 public IS[] getDRGGrouperReviewCode() { 655 IS[] retVal = this.getTypedField(10, new IS[0]); 656 return retVal; 657 } 658 659 660 /** 661 * Returns all repetitions of DRG Grouper Review Code (DG1-10). 662 */ 663 public IS[] getDg110_DRGGrouperReviewCode() { 664 IS[] retVal = this.getTypedField(10, new IS[0]); 665 return retVal; 666 } 667 668 669 /** 670 * Returns a count of the current number of repetitions of DRG Grouper Review Code (DG1-10). 671 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 672 * it will return zero. 673 */ 674 public int getDRGGrouperReviewCodeReps() { 675 return this.getReps(10); 676 } 677 678 679 /** 680 * Returns a specific repetition of 681 * DG1-10: "DRG Grouper Review Code" - creates it if necessary 682 * 683 * @param rep The repetition index (0-indexed) 684 */ 685 public IS getDRGGrouperReviewCode(int rep) { 686 IS retVal = this.getTypedField(10, rep); 687 return retVal; 688 } 689 690 /** 691 * Returns a specific repetition of 692 * DG1-10: "DRG Grouper Review Code" - creates it if necessary 693 * 694 * @param rep The repetition index (0-indexed) 695 */ 696 public IS getDg110_DRGGrouperReviewCode(int rep) { 697 IS retVal = this.getTypedField(10, rep); 698 return retVal; 699 } 700 701 /** 702 * Returns a count of the current number of repetitions of DRG Grouper Review Code (DG1-10). 703 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 704 * it will return zero. 705 */ 706 public int getDg110_DRGGrouperReviewCodeReps() { 707 return this.getReps(10); 708 } 709 710 711 /** 712 * Inserts a repetition of 713 * DG1-10: "DRG Grouper Review Code" at a specific index 714 * 715 * @param rep The repetition index (0-indexed) 716 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 717 */ 718 public IS insertDRGGrouperReviewCode(int rep) throws HL7Exception { 719 return (IS) super.insertRepetition(10, rep); 720 } 721 722 723 /** 724 * Inserts a repetition of 725 * DG1-10: "DRG Grouper Review Code" at a specific index 726 * 727 * @param rep The repetition index (0-indexed) 728 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 729 */ 730 public IS insertDg110_DRGGrouperReviewCode(int rep) throws HL7Exception { 731 return (IS) super.insertRepetition(10, rep); 732 } 733 734 735 /** 736 * Removes a repetition of 737 * DG1-10: "DRG Grouper Review Code" at a specific index 738 * 739 * @param rep The repetition index (0-indexed) 740 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 741 */ 742 public IS removeDRGGrouperReviewCode(int rep) throws HL7Exception { 743 return (IS) super.removeRepetition(10, rep); 744 } 745 746 747 /** 748 * Removes a repetition of 749 * DG1-10: "DRG Grouper Review Code" at a specific index 750 * 751 * @param rep The repetition index (0-indexed) 752 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 753 */ 754 public IS removeDg110_DRGGrouperReviewCode(int rep) throws HL7Exception { 755 return (IS) super.removeRepetition(10, rep); 756 } 757 758 759 760 /** 761 * Returns all repetitions of Outlier Type (DG1-11). 762 */ 763 public CE[] getOutlierType() { 764 CE[] retVal = this.getTypedField(11, new CE[0]); 765 return retVal; 766 } 767 768 769 /** 770 * Returns all repetitions of Outlier Type (DG1-11). 771 */ 772 public CE[] getDg111_OutlierType() { 773 CE[] retVal = this.getTypedField(11, new CE[0]); 774 return retVal; 775 } 776 777 778 /** 779 * Returns a count of the current number of repetitions of Outlier Type (DG1-11). 780 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 781 * it will return zero. 782 */ 783 public int getOutlierTypeReps() { 784 return this.getReps(11); 785 } 786 787 788 /** 789 * Returns a specific repetition of 790 * DG1-11: "Outlier Type" - creates it if necessary 791 * 792 * @param rep The repetition index (0-indexed) 793 */ 794 public CE getOutlierType(int rep) { 795 CE retVal = this.getTypedField(11, rep); 796 return retVal; 797 } 798 799 /** 800 * Returns a specific repetition of 801 * DG1-11: "Outlier Type" - creates it if necessary 802 * 803 * @param rep The repetition index (0-indexed) 804 */ 805 public CE getDg111_OutlierType(int rep) { 806 CE retVal = this.getTypedField(11, rep); 807 return retVal; 808 } 809 810 /** 811 * Returns a count of the current number of repetitions of Outlier Type (DG1-11). 812 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 813 * it will return zero. 814 */ 815 public int getDg111_OutlierTypeReps() { 816 return this.getReps(11); 817 } 818 819 820 /** 821 * Inserts a repetition of 822 * DG1-11: "Outlier Type" at a specific index 823 * 824 * @param rep The repetition index (0-indexed) 825 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 826 */ 827 public CE insertOutlierType(int rep) throws HL7Exception { 828 return (CE) super.insertRepetition(11, rep); 829 } 830 831 832 /** 833 * Inserts a repetition of 834 * DG1-11: "Outlier Type" at a specific index 835 * 836 * @param rep The repetition index (0-indexed) 837 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 838 */ 839 public CE insertDg111_OutlierType(int rep) throws HL7Exception { 840 return (CE) super.insertRepetition(11, rep); 841 } 842 843 844 /** 845 * Removes a repetition of 846 * DG1-11: "Outlier Type" at a specific index 847 * 848 * @param rep The repetition index (0-indexed) 849 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 850 */ 851 public CE removeOutlierType(int rep) throws HL7Exception { 852 return (CE) super.removeRepetition(11, rep); 853 } 854 855 856 /** 857 * Removes a repetition of 858 * DG1-11: "Outlier Type" at a specific index 859 * 860 * @param rep The repetition index (0-indexed) 861 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 862 */ 863 public CE removeDg111_OutlierType(int rep) throws HL7Exception { 864 return (CE) super.removeRepetition(11, rep); 865 } 866 867 868 869 /** 870 * Returns all repetitions of Outlier Days (DG1-12). 871 */ 872 public NM[] getOutlierDays() { 873 NM[] retVal = this.getTypedField(12, new NM[0]); 874 return retVal; 875 } 876 877 878 /** 879 * Returns all repetitions of Outlier Days (DG1-12). 880 */ 881 public NM[] getDg112_OutlierDays() { 882 NM[] retVal = this.getTypedField(12, new NM[0]); 883 return retVal; 884 } 885 886 887 /** 888 * Returns a count of the current number of repetitions of Outlier Days (DG1-12). 889 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 890 * it will return zero. 891 */ 892 public int getOutlierDaysReps() { 893 return this.getReps(12); 894 } 895 896 897 /** 898 * Returns a specific repetition of 899 * DG1-12: "Outlier Days" - creates it if necessary 900 * 901 * @param rep The repetition index (0-indexed) 902 */ 903 public NM getOutlierDays(int rep) { 904 NM retVal = this.getTypedField(12, rep); 905 return retVal; 906 } 907 908 /** 909 * Returns a specific repetition of 910 * DG1-12: "Outlier Days" - creates it if necessary 911 * 912 * @param rep The repetition index (0-indexed) 913 */ 914 public NM getDg112_OutlierDays(int rep) { 915 NM retVal = this.getTypedField(12, rep); 916 return retVal; 917 } 918 919 /** 920 * Returns a count of the current number of repetitions of Outlier Days (DG1-12). 921 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 922 * it will return zero. 923 */ 924 public int getDg112_OutlierDaysReps() { 925 return this.getReps(12); 926 } 927 928 929 /** 930 * Inserts a repetition of 931 * DG1-12: "Outlier Days" at a specific index 932 * 933 * @param rep The repetition index (0-indexed) 934 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 935 */ 936 public NM insertOutlierDays(int rep) throws HL7Exception { 937 return (NM) super.insertRepetition(12, rep); 938 } 939 940 941 /** 942 * Inserts a repetition of 943 * DG1-12: "Outlier Days" at a specific index 944 * 945 * @param rep The repetition index (0-indexed) 946 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 947 */ 948 public NM insertDg112_OutlierDays(int rep) throws HL7Exception { 949 return (NM) super.insertRepetition(12, rep); 950 } 951 952 953 /** 954 * Removes a repetition of 955 * DG1-12: "Outlier Days" at a specific index 956 * 957 * @param rep The repetition index (0-indexed) 958 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 959 */ 960 public NM removeOutlierDays(int rep) throws HL7Exception { 961 return (NM) super.removeRepetition(12, rep); 962 } 963 964 965 /** 966 * Removes a repetition of 967 * DG1-12: "Outlier Days" at a specific index 968 * 969 * @param rep The repetition index (0-indexed) 970 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 971 */ 972 public NM removeDg112_OutlierDays(int rep) throws HL7Exception { 973 return (NM) super.removeRepetition(12, rep); 974 } 975 976 977 978 /** 979 * Returns all repetitions of Outlier Cost (DG1-13). 980 */ 981 public CP[] getOutlierCost() { 982 CP[] retVal = this.getTypedField(13, new CP[0]); 983 return retVal; 984 } 985 986 987 /** 988 * Returns all repetitions of Outlier Cost (DG1-13). 989 */ 990 public CP[] getDg113_OutlierCost() { 991 CP[] retVal = this.getTypedField(13, new CP[0]); 992 return retVal; 993 } 994 995 996 /** 997 * Returns a count of the current number of repetitions of Outlier Cost (DG1-13). 998 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 999 * it will return zero. 1000 */ 1001 public int getOutlierCostReps() { 1002 return this.getReps(13); 1003 } 1004 1005 1006 /** 1007 * Returns a specific repetition of 1008 * DG1-13: "Outlier Cost" - creates it if necessary 1009 * 1010 * @param rep The repetition index (0-indexed) 1011 */ 1012 public CP getOutlierCost(int rep) { 1013 CP retVal = this.getTypedField(13, rep); 1014 return retVal; 1015 } 1016 1017 /** 1018 * Returns a specific repetition of 1019 * DG1-13: "Outlier Cost" - creates it if necessary 1020 * 1021 * @param rep The repetition index (0-indexed) 1022 */ 1023 public CP getDg113_OutlierCost(int rep) { 1024 CP retVal = this.getTypedField(13, rep); 1025 return retVal; 1026 } 1027 1028 /** 1029 * Returns a count of the current number of repetitions of Outlier Cost (DG1-13). 1030 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1031 * it will return zero. 1032 */ 1033 public int getDg113_OutlierCostReps() { 1034 return this.getReps(13); 1035 } 1036 1037 1038 /** 1039 * Inserts a repetition of 1040 * DG1-13: "Outlier Cost" at a specific index 1041 * 1042 * @param rep The repetition index (0-indexed) 1043 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1044 */ 1045 public CP insertOutlierCost(int rep) throws HL7Exception { 1046 return (CP) super.insertRepetition(13, rep); 1047 } 1048 1049 1050 /** 1051 * Inserts a repetition of 1052 * DG1-13: "Outlier Cost" at a specific index 1053 * 1054 * @param rep The repetition index (0-indexed) 1055 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1056 */ 1057 public CP insertDg113_OutlierCost(int rep) throws HL7Exception { 1058 return (CP) super.insertRepetition(13, rep); 1059 } 1060 1061 1062 /** 1063 * Removes a repetition of 1064 * DG1-13: "Outlier Cost" at a specific index 1065 * 1066 * @param rep The repetition index (0-indexed) 1067 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1068 */ 1069 public CP removeOutlierCost(int rep) throws HL7Exception { 1070 return (CP) super.removeRepetition(13, rep); 1071 } 1072 1073 1074 /** 1075 * Removes a repetition of 1076 * DG1-13: "Outlier Cost" at a specific index 1077 * 1078 * @param rep The repetition index (0-indexed) 1079 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1080 */ 1081 public CP removeDg113_OutlierCost(int rep) throws HL7Exception { 1082 return (CP) super.removeRepetition(13, rep); 1083 } 1084 1085 1086 1087 /** 1088 * Returns all repetitions of Grouper Version And Type (DG1-14). 1089 */ 1090 public ST[] getGrouperVersionAndType() { 1091 ST[] retVal = this.getTypedField(14, new ST[0]); 1092 return retVal; 1093 } 1094 1095 1096 /** 1097 * Returns all repetitions of Grouper Version And Type (DG1-14). 1098 */ 1099 public ST[] getDg114_GrouperVersionAndType() { 1100 ST[] retVal = this.getTypedField(14, new ST[0]); 1101 return retVal; 1102 } 1103 1104 1105 /** 1106 * Returns a count of the current number of repetitions of Grouper Version And Type (DG1-14). 1107 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1108 * it will return zero. 1109 */ 1110 public int getGrouperVersionAndTypeReps() { 1111 return this.getReps(14); 1112 } 1113 1114 1115 /** 1116 * Returns a specific repetition of 1117 * DG1-14: "Grouper Version And Type" - creates it if necessary 1118 * 1119 * @param rep The repetition index (0-indexed) 1120 */ 1121 public ST getGrouperVersionAndType(int rep) { 1122 ST retVal = this.getTypedField(14, rep); 1123 return retVal; 1124 } 1125 1126 /** 1127 * Returns a specific repetition of 1128 * DG1-14: "Grouper Version And Type" - creates it if necessary 1129 * 1130 * @param rep The repetition index (0-indexed) 1131 */ 1132 public ST getDg114_GrouperVersionAndType(int rep) { 1133 ST retVal = this.getTypedField(14, rep); 1134 return retVal; 1135 } 1136 1137 /** 1138 * Returns a count of the current number of repetitions of Grouper Version And Type (DG1-14). 1139 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1140 * it will return zero. 1141 */ 1142 public int getDg114_GrouperVersionAndTypeReps() { 1143 return this.getReps(14); 1144 } 1145 1146 1147 /** 1148 * Inserts a repetition of 1149 * DG1-14: "Grouper Version And Type" at a specific index 1150 * 1151 * @param rep The repetition index (0-indexed) 1152 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1153 */ 1154 public ST insertGrouperVersionAndType(int rep) throws HL7Exception { 1155 return (ST) super.insertRepetition(14, rep); 1156 } 1157 1158 1159 /** 1160 * Inserts a repetition of 1161 * DG1-14: "Grouper Version And Type" at a specific index 1162 * 1163 * @param rep The repetition index (0-indexed) 1164 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1165 */ 1166 public ST insertDg114_GrouperVersionAndType(int rep) throws HL7Exception { 1167 return (ST) super.insertRepetition(14, rep); 1168 } 1169 1170 1171 /** 1172 * Removes a repetition of 1173 * DG1-14: "Grouper Version And Type" at a specific index 1174 * 1175 * @param rep The repetition index (0-indexed) 1176 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1177 */ 1178 public ST removeGrouperVersionAndType(int rep) throws HL7Exception { 1179 return (ST) super.removeRepetition(14, rep); 1180 } 1181 1182 1183 /** 1184 * Removes a repetition of 1185 * DG1-14: "Grouper Version And Type" at a specific index 1186 * 1187 * @param rep The repetition index (0-indexed) 1188 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1189 */ 1190 public ST removeDg114_GrouperVersionAndType(int rep) throws HL7Exception { 1191 return (ST) super.removeRepetition(14, rep); 1192 } 1193 1194 1195 1196 1197 /** 1198 * Returns 1199 * DG1-15: "Diagnosis Priority" - creates it if necessary 1200 */ 1201 public ID getDiagnosisPriority() { 1202 ID retVal = this.getTypedField(15, 0); 1203 return retVal; 1204 } 1205 1206 /** 1207 * Returns 1208 * DG1-15: "Diagnosis Priority" - creates it if necessary 1209 */ 1210 public ID getDg115_DiagnosisPriority() { 1211 ID retVal = this.getTypedField(15, 0); 1212 return retVal; 1213 } 1214 1215 1216 /** 1217 * Returns all repetitions of Diagnosing Clinician (DG1-16). 1218 */ 1219 public XCN[] getDiagnosingClinician() { 1220 XCN[] retVal = this.getTypedField(16, new XCN[0]); 1221 return retVal; 1222 } 1223 1224 1225 /** 1226 * Returns all repetitions of Diagnosing Clinician (DG1-16). 1227 */ 1228 public XCN[] getDg116_DiagnosingClinician() { 1229 XCN[] retVal = this.getTypedField(16, new XCN[0]); 1230 return retVal; 1231 } 1232 1233 1234 /** 1235 * Returns a count of the current number of repetitions of Diagnosing Clinician (DG1-16). 1236 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1237 * it will return zero. 1238 */ 1239 public int getDiagnosingClinicianReps() { 1240 return this.getReps(16); 1241 } 1242 1243 1244 /** 1245 * Returns a specific repetition of 1246 * DG1-16: "Diagnosing Clinician" - creates it if necessary 1247 * 1248 * @param rep The repetition index (0-indexed) 1249 */ 1250 public XCN getDiagnosingClinician(int rep) { 1251 XCN retVal = this.getTypedField(16, rep); 1252 return retVal; 1253 } 1254 1255 /** 1256 * Returns a specific repetition of 1257 * DG1-16: "Diagnosing Clinician" - creates it if necessary 1258 * 1259 * @param rep The repetition index (0-indexed) 1260 */ 1261 public XCN getDg116_DiagnosingClinician(int rep) { 1262 XCN retVal = this.getTypedField(16, rep); 1263 return retVal; 1264 } 1265 1266 /** 1267 * Returns a count of the current number of repetitions of Diagnosing Clinician (DG1-16). 1268 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1269 * it will return zero. 1270 */ 1271 public int getDg116_DiagnosingClinicianReps() { 1272 return this.getReps(16); 1273 } 1274 1275 1276 /** 1277 * Inserts a repetition of 1278 * DG1-16: "Diagnosing Clinician" at a specific index 1279 * 1280 * @param rep The repetition index (0-indexed) 1281 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1282 */ 1283 public XCN insertDiagnosingClinician(int rep) throws HL7Exception { 1284 return (XCN) super.insertRepetition(16, rep); 1285 } 1286 1287 1288 /** 1289 * Inserts a repetition of 1290 * DG1-16: "Diagnosing Clinician" at a specific index 1291 * 1292 * @param rep The repetition index (0-indexed) 1293 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1294 */ 1295 public XCN insertDg116_DiagnosingClinician(int rep) throws HL7Exception { 1296 return (XCN) super.insertRepetition(16, rep); 1297 } 1298 1299 1300 /** 1301 * Removes a repetition of 1302 * DG1-16: "Diagnosing Clinician" at a specific index 1303 * 1304 * @param rep The repetition index (0-indexed) 1305 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1306 */ 1307 public XCN removeDiagnosingClinician(int rep) throws HL7Exception { 1308 return (XCN) super.removeRepetition(16, rep); 1309 } 1310 1311 1312 /** 1313 * Removes a repetition of 1314 * DG1-16: "Diagnosing Clinician" at a specific index 1315 * 1316 * @param rep The repetition index (0-indexed) 1317 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1318 */ 1319 public XCN removeDg116_DiagnosingClinician(int rep) throws HL7Exception { 1320 return (XCN) super.removeRepetition(16, rep); 1321 } 1322 1323 1324 1325 1326 /** 1327 * Returns 1328 * DG1-17: "Diagnosis Classification" - creates it if necessary 1329 */ 1330 public IS getDiagnosisClassification() { 1331 IS retVal = this.getTypedField(17, 0); 1332 return retVal; 1333 } 1334 1335 /** 1336 * Returns 1337 * DG1-17: "Diagnosis Classification" - creates it if necessary 1338 */ 1339 public IS getDg117_DiagnosisClassification() { 1340 IS retVal = this.getTypedField(17, 0); 1341 return retVal; 1342 } 1343 1344 1345 1346 /** 1347 * Returns 1348 * DG1-18: "Confidential Indicator" - creates it if necessary 1349 */ 1350 public ID getConfidentialIndicator() { 1351 ID retVal = this.getTypedField(18, 0); 1352 return retVal; 1353 } 1354 1355 /** 1356 * Returns 1357 * DG1-18: "Confidential Indicator" - creates it if necessary 1358 */ 1359 public ID getDg118_ConfidentialIndicator() { 1360 ID retVal = this.getTypedField(18, 0); 1361 return retVal; 1362 } 1363 1364 1365 1366 /** 1367 * Returns 1368 * DG1-19: "Attestation Date/Time" - creates it if necessary 1369 */ 1370 public TS getAttestationDateTime() { 1371 TS retVal = this.getTypedField(19, 0); 1372 return retVal; 1373 } 1374 1375 /** 1376 * Returns 1377 * DG1-19: "Attestation Date/Time" - creates it if necessary 1378 */ 1379 public TS getDg119_AttestationDateTime() { 1380 TS retVal = this.getTypedField(19, 0); 1381 return retVal; 1382 } 1383 1384 1385 1386 /** 1387 * Returns 1388 * DG1-20: "Diagnosis Identifier" - creates it if necessary 1389 */ 1390 public EI getDiagnosisIdentifier() { 1391 EI retVal = this.getTypedField(20, 0); 1392 return retVal; 1393 } 1394 1395 /** 1396 * Returns 1397 * DG1-20: "Diagnosis Identifier" - creates it if necessary 1398 */ 1399 public EI getDg120_DiagnosisIdentifier() { 1400 EI retVal = this.getTypedField(20, 0); 1401 return retVal; 1402 } 1403 1404 1405 1406 /** 1407 * Returns 1408 * DG1-21: "Diagnosis Action Code" - creates it if necessary 1409 */ 1410 public ID getDiagnosisActionCode() { 1411 ID retVal = this.getTypedField(21, 0); 1412 return retVal; 1413 } 1414 1415 /** 1416 * Returns 1417 * DG1-21: "Diagnosis Action Code" - creates it if necessary 1418 */ 1419 public ID getDg121_DiagnosisActionCode() { 1420 ID retVal = this.getTypedField(21, 0); 1421 return retVal; 1422 } 1423 1424 1425 1426 1427 1428 /** {@inheritDoc} */ 1429 protected Type createNewTypeWithoutReflection(int field) { 1430 switch (field) { 1431 case 0: return new SI(getMessage()); 1432 case 1: return new ID(getMessage(), new Integer( 53 )); 1433 case 2: return new CE(getMessage()); 1434 case 3: return new ST(getMessage()); 1435 case 4: return new TS(getMessage()); 1436 case 5: return new IS(getMessage(), new Integer( 52 )); 1437 case 6: return new CE(getMessage()); 1438 case 7: return new CE(getMessage()); 1439 case 8: return new ID(getMessage(), new Integer( 136 )); 1440 case 9: return new IS(getMessage(), new Integer( 56 )); 1441 case 10: return new CE(getMessage()); 1442 case 11: return new NM(getMessage()); 1443 case 12: return new CP(getMessage()); 1444 case 13: return new ST(getMessage()); 1445 case 14: return new ID(getMessage(), new Integer( 359 )); 1446 case 15: return new XCN(getMessage()); 1447 case 16: return new IS(getMessage(), new Integer( 228 )); 1448 case 17: return new ID(getMessage(), new Integer( 136 )); 1449 case 18: return new TS(getMessage()); 1450 case 19: return new EI(getMessage()); 1451 case 20: return new ID(getMessage(), new Integer( 206 )); 1452 default: return null; 1453 } 1454 } 1455 1456 1457 } 1458