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.model.v25.segment; 35 36 // import ca.uhn.hl7v2.model.v25.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 UB2 message segment (UB92 Data). 50 * This segment has the following fields:</p> 51 * <ul> 52 * <li>UB2-1: Set ID - UB2 (SI) <b>optional </b> 53 * <li>UB2-2: Co-Insurance Days (9) (ST) <b>optional </b> 54 * <li>UB2-3: Condition Code (24-30) (IS) <b>optional repeating</b> 55 * <li>UB2-4: Covered Days (7) (ST) <b>optional </b> 56 * <li>UB2-5: Non-Covered Days (8) (ST) <b>optional </b> 57 * <li>UB2-6: Value Amount & Code (UVC) <b>optional repeating</b> 58 * <li>UB2-7: Occurrence Code & Date (32-35) (OCD) <b>optional repeating</b> 59 * <li>UB2-8: Occurrence Span Code/Dates (36) (OSP) <b>optional repeating</b> 60 * <li>UB2-9: UB92 Locator 2 (State) (ST) <b>optional repeating</b> 61 * <li>UB2-10: UB92 Locator 11 (State) (ST) <b>optional repeating</b> 62 * <li>UB2-11: UB92 Locator 31 (National) (ST) <b>optional </b> 63 * <li>UB2-12: Document Control Number (ST) <b>optional repeating</b> 64 * <li>UB2-13: UB92 Locator 49 (National) (ST) <b>optional repeating</b> 65 * <li>UB2-14: UB92 Locator 56 (State) (ST) <b>optional repeating</b> 66 * <li>UB2-15: UB92 Locator 57 (National) (ST) <b>optional </b> 67 * <li>UB2-16: UB92 Locator 78 (State) (ST) <b>optional repeating</b> 68 * <li>UB2-17: Special Visit Count (NM) <b>optional </b> 69 * </ul> 70 */ 71 @SuppressWarnings("unused") 72 public class UB2 extends AbstractSegment { 73 74 /** 75 * Creates a new UB2 segment 76 */ 77 public UB2(Group parent, ModelClassFactory factory) { 78 super(parent, factory); 79 init(factory); 80 } 81 82 private void init(ModelClassFactory factory) { 83 try { 84 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - UB2"); 85 this.add(ST.class, false, 1, 3, new Object[]{ getMessage() }, "Co-Insurance Days (9)"); 86 this.add(IS.class, false, 0, 2, new Object[]{ getMessage(), new Integer(43) }, "Condition Code (24-30)"); 87 this.add(ST.class, false, 1, 3, new Object[]{ getMessage() }, "Covered Days (7)"); 88 this.add(ST.class, false, 1, 4, new Object[]{ getMessage() }, "Non-Covered Days (8)"); 89 this.add(UVC.class, false, 0, 41, new Object[]{ getMessage() }, "Value Amount & Code"); 90 this.add(OCD.class, false, 0, 259, new Object[]{ getMessage() }, "Occurrence Code & Date (32-35)"); 91 this.add(OSP.class, false, 0, 268, new Object[]{ getMessage() }, "Occurrence Span Code/Dates (36)"); 92 this.add(ST.class, false, 0, 29, new Object[]{ getMessage() }, "UB92 Locator 2 (State)"); 93 this.add(ST.class, false, 0, 12, new Object[]{ getMessage() }, "UB92 Locator 11 (State)"); 94 this.add(ST.class, false, 1, 5, new Object[]{ getMessage() }, "UB92 Locator 31 (National)"); 95 this.add(ST.class, false, 0, 23, new Object[]{ getMessage() }, "Document Control Number"); 96 this.add(ST.class, false, 0, 4, new Object[]{ getMessage() }, "UB92 Locator 49 (National)"); 97 this.add(ST.class, false, 0, 14, new Object[]{ getMessage() }, "UB92 Locator 56 (State)"); 98 this.add(ST.class, false, 1, 27, new Object[]{ getMessage() }, "UB92 Locator 57 (National)"); 99 this.add(ST.class, false, 0, 2, new Object[]{ getMessage() }, "UB92 Locator 78 (State)"); 100 this.add(NM.class, false, 1, 3, new Object[]{ getMessage() }, "Special Visit Count"); 101 } catch(HL7Exception e) { 102 log.error("Unexpected error creating UB2 - this is probably a bug in the source code generator.", e); 103 } 104 } 105 106 107 108 /** 109 * Returns 110 * UB2-1: "Set ID - UB2" - creates it if necessary 111 */ 112 public SI getSetIDUB2() { 113 SI retVal = this.getTypedField(1, 0); 114 return retVal; 115 } 116 117 /** 118 * Returns 119 * UB2-1: "Set ID - UB2" - creates it if necessary 120 */ 121 public SI getUb21_SetIDUB2() { 122 SI retVal = this.getTypedField(1, 0); 123 return retVal; 124 } 125 126 127 128 /** 129 * Returns 130 * UB2-2: "Co-Insurance Days (9)" - creates it if necessary 131 */ 132 public ST getCoInsuranceDays9() { 133 ST retVal = this.getTypedField(2, 0); 134 return retVal; 135 } 136 137 /** 138 * Returns 139 * UB2-2: "Co-Insurance Days (9)" - creates it if necessary 140 */ 141 public ST getUb22_CoInsuranceDays9() { 142 ST retVal = this.getTypedField(2, 0); 143 return retVal; 144 } 145 146 147 /** 148 * Returns all repetitions of Condition Code (24-30) (UB2-3). 149 */ 150 public IS[] getConditionCode2430() { 151 IS[] retVal = this.getTypedField(3, new IS[0]); 152 return retVal; 153 } 154 155 156 /** 157 * Returns all repetitions of Condition Code (24-30) (UB2-3). 158 */ 159 public IS[] getUb23_ConditionCode2430() { 160 IS[] retVal = this.getTypedField(3, new IS[0]); 161 return retVal; 162 } 163 164 165 /** 166 * Returns a count of the current number of repetitions of Condition Code (24-30) (UB2-3). 167 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 168 * it will return zero. 169 */ 170 public int getConditionCode2430Reps() { 171 return this.getReps(3); 172 } 173 174 175 /** 176 * Returns a specific repetition of 177 * UB2-3: "Condition Code (24-30)" - creates it if necessary 178 * 179 * @param rep The repetition index (0-indexed) 180 */ 181 public IS getConditionCode2430(int rep) { 182 IS retVal = this.getTypedField(3, rep); 183 return retVal; 184 } 185 186 /** 187 * Returns a specific repetition of 188 * UB2-3: "Condition Code (24-30)" - creates it if necessary 189 * 190 * @param rep The repetition index (0-indexed) 191 */ 192 public IS getUb23_ConditionCode2430(int rep) { 193 IS retVal = this.getTypedField(3, rep); 194 return retVal; 195 } 196 197 /** 198 * Returns a count of the current number of repetitions of Condition Code (24-30) (UB2-3). 199 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 200 * it will return zero. 201 */ 202 public int getUb23_ConditionCode2430Reps() { 203 return this.getReps(3); 204 } 205 206 207 /** 208 * Inserts a repetition of 209 * UB2-3: "Condition Code (24-30)" at a specific index 210 * 211 * @param rep The repetition index (0-indexed) 212 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 213 */ 214 public IS insertConditionCode2430(int rep) throws HL7Exception { 215 return (IS) super.insertRepetition(3, rep); 216 } 217 218 219 /** 220 * Inserts a repetition of 221 * UB2-3: "Condition Code (24-30)" at a specific index 222 * 223 * @param rep The repetition index (0-indexed) 224 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 225 */ 226 public IS insertUb23_ConditionCode2430(int rep) throws HL7Exception { 227 return (IS) super.insertRepetition(3, rep); 228 } 229 230 231 /** 232 * Removes a repetition of 233 * UB2-3: "Condition Code (24-30)" 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 IS removeConditionCode2430(int rep) throws HL7Exception { 239 return (IS) super.removeRepetition(3, rep); 240 } 241 242 243 /** 244 * Removes a repetition of 245 * UB2-3: "Condition Code (24-30)" 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 IS removeUb23_ConditionCode2430(int rep) throws HL7Exception { 251 return (IS) super.removeRepetition(3, rep); 252 } 253 254 255 256 257 /** 258 * Returns 259 * UB2-4: "Covered Days (7)" - creates it if necessary 260 */ 261 public ST getCoveredDays7() { 262 ST retVal = this.getTypedField(4, 0); 263 return retVal; 264 } 265 266 /** 267 * Returns 268 * UB2-4: "Covered Days (7)" - creates it if necessary 269 */ 270 public ST getUb24_CoveredDays7() { 271 ST retVal = this.getTypedField(4, 0); 272 return retVal; 273 } 274 275 276 277 /** 278 * Returns 279 * UB2-5: "Non-Covered Days (8)" - creates it if necessary 280 */ 281 public ST getNonCoveredDays8() { 282 ST retVal = this.getTypedField(5, 0); 283 return retVal; 284 } 285 286 /** 287 * Returns 288 * UB2-5: "Non-Covered Days (8)" - creates it if necessary 289 */ 290 public ST getUb25_NonCoveredDays8() { 291 ST retVal = this.getTypedField(5, 0); 292 return retVal; 293 } 294 295 296 /** 297 * Returns all repetitions of Value Amount & Code (UB2-6). 298 */ 299 public UVC[] getValueAmountCode() { 300 UVC[] retVal = this.getTypedField(6, new UVC[0]); 301 return retVal; 302 } 303 304 305 /** 306 * Returns all repetitions of Value Amount & Code (UB2-6). 307 */ 308 public UVC[] getUb26_ValueAmountCode() { 309 UVC[] retVal = this.getTypedField(6, new UVC[0]); 310 return retVal; 311 } 312 313 314 /** 315 * Returns a count of the current number of repetitions of Value Amount & Code (UB2-6). 316 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 317 * it will return zero. 318 */ 319 public int getValueAmountCodeReps() { 320 return this.getReps(6); 321 } 322 323 324 /** 325 * Returns a specific repetition of 326 * UB2-6: "Value Amount & Code" - creates it if necessary 327 * 328 * @param rep The repetition index (0-indexed) 329 */ 330 public UVC getValueAmountCode(int rep) { 331 UVC retVal = this.getTypedField(6, rep); 332 return retVal; 333 } 334 335 /** 336 * Returns a specific repetition of 337 * UB2-6: "Value Amount & Code" - creates it if necessary 338 * 339 * @param rep The repetition index (0-indexed) 340 */ 341 public UVC getUb26_ValueAmountCode(int rep) { 342 UVC retVal = this.getTypedField(6, rep); 343 return retVal; 344 } 345 346 /** 347 * Returns a count of the current number of repetitions of Value Amount & Code (UB2-6). 348 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 349 * it will return zero. 350 */ 351 public int getUb26_ValueAmountCodeReps() { 352 return this.getReps(6); 353 } 354 355 356 /** 357 * Inserts a repetition of 358 * UB2-6: "Value Amount & Code" at a specific index 359 * 360 * @param rep The repetition index (0-indexed) 361 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 362 */ 363 public UVC insertValueAmountCode(int rep) throws HL7Exception { 364 return (UVC) super.insertRepetition(6, rep); 365 } 366 367 368 /** 369 * Inserts a repetition of 370 * UB2-6: "Value Amount & Code" at a specific index 371 * 372 * @param rep The repetition index (0-indexed) 373 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 374 */ 375 public UVC insertUb26_ValueAmountCode(int rep) throws HL7Exception { 376 return (UVC) super.insertRepetition(6, rep); 377 } 378 379 380 /** 381 * Removes a repetition of 382 * UB2-6: "Value Amount & Code" at a specific index 383 * 384 * @param rep The repetition index (0-indexed) 385 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 386 */ 387 public UVC removeValueAmountCode(int rep) throws HL7Exception { 388 return (UVC) super.removeRepetition(6, rep); 389 } 390 391 392 /** 393 * Removes a repetition of 394 * UB2-6: "Value Amount & Code" at a specific index 395 * 396 * @param rep The repetition index (0-indexed) 397 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 398 */ 399 public UVC removeUb26_ValueAmountCode(int rep) throws HL7Exception { 400 return (UVC) super.removeRepetition(6, rep); 401 } 402 403 404 405 /** 406 * Returns all repetitions of Occurrence Code & Date (32-35) (UB2-7). 407 */ 408 public OCD[] getOccurrenceCodeDate3235() { 409 OCD[] retVal = this.getTypedField(7, new OCD[0]); 410 return retVal; 411 } 412 413 414 /** 415 * Returns all repetitions of Occurrence Code & Date (32-35) (UB2-7). 416 */ 417 public OCD[] getUb27_OccurrenceCodeDate3235() { 418 OCD[] retVal = this.getTypedField(7, new OCD[0]); 419 return retVal; 420 } 421 422 423 /** 424 * Returns a count of the current number of repetitions of Occurrence Code & Date (32-35) (UB2-7). 425 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 426 * it will return zero. 427 */ 428 public int getOccurrenceCodeDate3235Reps() { 429 return this.getReps(7); 430 } 431 432 433 /** 434 * Returns a specific repetition of 435 * UB2-7: "Occurrence Code & Date (32-35)" - creates it if necessary 436 * 437 * @param rep The repetition index (0-indexed) 438 */ 439 public OCD getOccurrenceCodeDate3235(int rep) { 440 OCD retVal = this.getTypedField(7, rep); 441 return retVal; 442 } 443 444 /** 445 * Returns a specific repetition of 446 * UB2-7: "Occurrence Code & Date (32-35)" - creates it if necessary 447 * 448 * @param rep The repetition index (0-indexed) 449 */ 450 public OCD getUb27_OccurrenceCodeDate3235(int rep) { 451 OCD retVal = this.getTypedField(7, rep); 452 return retVal; 453 } 454 455 /** 456 * Returns a count of the current number of repetitions of Occurrence Code & Date (32-35) (UB2-7). 457 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 458 * it will return zero. 459 */ 460 public int getUb27_OccurrenceCodeDate3235Reps() { 461 return this.getReps(7); 462 } 463 464 465 /** 466 * Inserts a repetition of 467 * UB2-7: "Occurrence Code & Date (32-35)" at a specific index 468 * 469 * @param rep The repetition index (0-indexed) 470 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 471 */ 472 public OCD insertOccurrenceCodeDate3235(int rep) throws HL7Exception { 473 return (OCD) super.insertRepetition(7, rep); 474 } 475 476 477 /** 478 * Inserts a repetition of 479 * UB2-7: "Occurrence Code & Date (32-35)" at a specific index 480 * 481 * @param rep The repetition index (0-indexed) 482 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 483 */ 484 public OCD insertUb27_OccurrenceCodeDate3235(int rep) throws HL7Exception { 485 return (OCD) super.insertRepetition(7, rep); 486 } 487 488 489 /** 490 * Removes a repetition of 491 * UB2-7: "Occurrence Code & Date (32-35)" at a specific index 492 * 493 * @param rep The repetition index (0-indexed) 494 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 495 */ 496 public OCD removeOccurrenceCodeDate3235(int rep) throws HL7Exception { 497 return (OCD) super.removeRepetition(7, rep); 498 } 499 500 501 /** 502 * Removes a repetition of 503 * UB2-7: "Occurrence Code & Date (32-35)" at a specific index 504 * 505 * @param rep The repetition index (0-indexed) 506 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 507 */ 508 public OCD removeUb27_OccurrenceCodeDate3235(int rep) throws HL7Exception { 509 return (OCD) super.removeRepetition(7, rep); 510 } 511 512 513 514 /** 515 * Returns all repetitions of Occurrence Span Code/Dates (36) (UB2-8). 516 */ 517 public OSP[] getOccurrenceSpanCodeDates() { 518 OSP[] retVal = this.getTypedField(8, new OSP[0]); 519 return retVal; 520 } 521 522 523 /** 524 * Returns all repetitions of Occurrence Span Code/Dates (36) (UB2-8). 525 */ 526 public OSP[] getUb28_OccurrenceSpanCodeDates() { 527 OSP[] retVal = this.getTypedField(8, new OSP[0]); 528 return retVal; 529 } 530 531 532 /** 533 * Returns a count of the current number of repetitions of Occurrence Span Code/Dates (36) (UB2-8). 534 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 535 * it will return zero. 536 */ 537 public int getOccurrenceSpanCodeDatesReps() { 538 return this.getReps(8); 539 } 540 541 542 /** 543 * Returns a specific repetition of 544 * UB2-8: "Occurrence Span Code/Dates (36)" - creates it if necessary 545 * 546 * @param rep The repetition index (0-indexed) 547 */ 548 public OSP getOccurrenceSpanCodeDates(int rep) { 549 OSP retVal = this.getTypedField(8, rep); 550 return retVal; 551 } 552 553 /** 554 * Returns a specific repetition of 555 * UB2-8: "Occurrence Span Code/Dates (36)" - creates it if necessary 556 * 557 * @param rep The repetition index (0-indexed) 558 */ 559 public OSP getUb28_OccurrenceSpanCodeDates(int rep) { 560 OSP retVal = this.getTypedField(8, rep); 561 return retVal; 562 } 563 564 /** 565 * Returns a count of the current number of repetitions of Occurrence Span Code/Dates (36) (UB2-8). 566 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 567 * it will return zero. 568 */ 569 public int getUb28_OccurrenceSpanCodeDatesReps() { 570 return this.getReps(8); 571 } 572 573 574 /** 575 * Inserts a repetition of 576 * UB2-8: "Occurrence Span Code/Dates (36)" at a specific index 577 * 578 * @param rep The repetition index (0-indexed) 579 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 580 */ 581 public OSP insertOccurrenceSpanCodeDates(int rep) throws HL7Exception { 582 return (OSP) super.insertRepetition(8, rep); 583 } 584 585 586 /** 587 * Inserts a repetition of 588 * UB2-8: "Occurrence Span Code/Dates (36)" at a specific index 589 * 590 * @param rep The repetition index (0-indexed) 591 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 592 */ 593 public OSP insertUb28_OccurrenceSpanCodeDates(int rep) throws HL7Exception { 594 return (OSP) super.insertRepetition(8, rep); 595 } 596 597 598 /** 599 * Removes a repetition of 600 * UB2-8: "Occurrence Span Code/Dates (36)" at a specific index 601 * 602 * @param rep The repetition index (0-indexed) 603 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 604 */ 605 public OSP removeOccurrenceSpanCodeDates(int rep) throws HL7Exception { 606 return (OSP) super.removeRepetition(8, rep); 607 } 608 609 610 /** 611 * Removes a repetition of 612 * UB2-8: "Occurrence Span Code/Dates (36)" at a specific index 613 * 614 * @param rep The repetition index (0-indexed) 615 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 616 */ 617 public OSP removeUb28_OccurrenceSpanCodeDates(int rep) throws HL7Exception { 618 return (OSP) super.removeRepetition(8, rep); 619 } 620 621 622 623 /** 624 * Returns all repetitions of UB92 Locator 2 (State) (UB2-9). 625 */ 626 public ST[] getUB92Locator2State() { 627 ST[] retVal = this.getTypedField(9, new ST[0]); 628 return retVal; 629 } 630 631 632 /** 633 * Returns all repetitions of UB92 Locator 2 (State) (UB2-9). 634 */ 635 public ST[] getUb29_UB92Locator2State() { 636 ST[] retVal = this.getTypedField(9, new ST[0]); 637 return retVal; 638 } 639 640 641 /** 642 * Returns a count of the current number of repetitions of UB92 Locator 2 (State) (UB2-9). 643 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 644 * it will return zero. 645 */ 646 public int getUB92Locator2StateReps() { 647 return this.getReps(9); 648 } 649 650 651 /** 652 * Returns a specific repetition of 653 * UB2-9: "UB92 Locator 2 (State)" - creates it if necessary 654 * 655 * @param rep The repetition index (0-indexed) 656 */ 657 public ST getUB92Locator2State(int rep) { 658 ST retVal = this.getTypedField(9, rep); 659 return retVal; 660 } 661 662 /** 663 * Returns a specific repetition of 664 * UB2-9: "UB92 Locator 2 (State)" - creates it if necessary 665 * 666 * @param rep The repetition index (0-indexed) 667 */ 668 public ST getUb29_UB92Locator2State(int rep) { 669 ST retVal = this.getTypedField(9, rep); 670 return retVal; 671 } 672 673 /** 674 * Returns a count of the current number of repetitions of UB92 Locator 2 (State) (UB2-9). 675 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 676 * it will return zero. 677 */ 678 public int getUb29_UB92Locator2StateReps() { 679 return this.getReps(9); 680 } 681 682 683 /** 684 * Inserts a repetition of 685 * UB2-9: "UB92 Locator 2 (State)" at a specific index 686 * 687 * @param rep The repetition index (0-indexed) 688 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 689 */ 690 public ST insertUB92Locator2State(int rep) throws HL7Exception { 691 return (ST) super.insertRepetition(9, rep); 692 } 693 694 695 /** 696 * Inserts a repetition of 697 * UB2-9: "UB92 Locator 2 (State)" at a specific index 698 * 699 * @param rep The repetition index (0-indexed) 700 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 701 */ 702 public ST insertUb29_UB92Locator2State(int rep) throws HL7Exception { 703 return (ST) super.insertRepetition(9, rep); 704 } 705 706 707 /** 708 * Removes a repetition of 709 * UB2-9: "UB92 Locator 2 (State)" at a specific index 710 * 711 * @param rep The repetition index (0-indexed) 712 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 713 */ 714 public ST removeUB92Locator2State(int rep) throws HL7Exception { 715 return (ST) super.removeRepetition(9, rep); 716 } 717 718 719 /** 720 * Removes a repetition of 721 * UB2-9: "UB92 Locator 2 (State)" at a specific index 722 * 723 * @param rep The repetition index (0-indexed) 724 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 725 */ 726 public ST removeUb29_UB92Locator2State(int rep) throws HL7Exception { 727 return (ST) super.removeRepetition(9, rep); 728 } 729 730 731 732 /** 733 * Returns all repetitions of UB92 Locator 11 (State) (UB2-10). 734 */ 735 public ST[] getUB92Locator11State() { 736 ST[] retVal = this.getTypedField(10, new ST[0]); 737 return retVal; 738 } 739 740 741 /** 742 * Returns all repetitions of UB92 Locator 11 (State) (UB2-10). 743 */ 744 public ST[] getUb210_UB92Locator11State() { 745 ST[] retVal = this.getTypedField(10, new ST[0]); 746 return retVal; 747 } 748 749 750 /** 751 * Returns a count of the current number of repetitions of UB92 Locator 11 (State) (UB2-10). 752 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 753 * it will return zero. 754 */ 755 public int getUB92Locator11StateReps() { 756 return this.getReps(10); 757 } 758 759 760 /** 761 * Returns a specific repetition of 762 * UB2-10: "UB92 Locator 11 (State)" - creates it if necessary 763 * 764 * @param rep The repetition index (0-indexed) 765 */ 766 public ST getUB92Locator11State(int rep) { 767 ST retVal = this.getTypedField(10, rep); 768 return retVal; 769 } 770 771 /** 772 * Returns a specific repetition of 773 * UB2-10: "UB92 Locator 11 (State)" - creates it if necessary 774 * 775 * @param rep The repetition index (0-indexed) 776 */ 777 public ST getUb210_UB92Locator11State(int rep) { 778 ST retVal = this.getTypedField(10, rep); 779 return retVal; 780 } 781 782 /** 783 * Returns a count of the current number of repetitions of UB92 Locator 11 (State) (UB2-10). 784 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 785 * it will return zero. 786 */ 787 public int getUb210_UB92Locator11StateReps() { 788 return this.getReps(10); 789 } 790 791 792 /** 793 * Inserts a repetition of 794 * UB2-10: "UB92 Locator 11 (State)" at a specific index 795 * 796 * @param rep The repetition index (0-indexed) 797 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 798 */ 799 public ST insertUB92Locator11State(int rep) throws HL7Exception { 800 return (ST) super.insertRepetition(10, rep); 801 } 802 803 804 /** 805 * Inserts a repetition of 806 * UB2-10: "UB92 Locator 11 (State)" at a specific index 807 * 808 * @param rep The repetition index (0-indexed) 809 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 810 */ 811 public ST insertUb210_UB92Locator11State(int rep) throws HL7Exception { 812 return (ST) super.insertRepetition(10, rep); 813 } 814 815 816 /** 817 * Removes a repetition of 818 * UB2-10: "UB92 Locator 11 (State)" at a specific index 819 * 820 * @param rep The repetition index (0-indexed) 821 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 822 */ 823 public ST removeUB92Locator11State(int rep) throws HL7Exception { 824 return (ST) super.removeRepetition(10, rep); 825 } 826 827 828 /** 829 * Removes a repetition of 830 * UB2-10: "UB92 Locator 11 (State)" at a specific index 831 * 832 * @param rep The repetition index (0-indexed) 833 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 834 */ 835 public ST removeUb210_UB92Locator11State(int rep) throws HL7Exception { 836 return (ST) super.removeRepetition(10, rep); 837 } 838 839 840 841 842 /** 843 * Returns 844 * UB2-11: "UB92 Locator 31 (National)" - creates it if necessary 845 */ 846 public ST getUB92Locator31National() { 847 ST retVal = this.getTypedField(11, 0); 848 return retVal; 849 } 850 851 /** 852 * Returns 853 * UB2-11: "UB92 Locator 31 (National)" - creates it if necessary 854 */ 855 public ST getUb211_UB92Locator31National() { 856 ST retVal = this.getTypedField(11, 0); 857 return retVal; 858 } 859 860 861 /** 862 * Returns all repetitions of Document Control Number (UB2-12). 863 */ 864 public ST[] getDocumentControlNumber() { 865 ST[] retVal = this.getTypedField(12, new ST[0]); 866 return retVal; 867 } 868 869 870 /** 871 * Returns all repetitions of Document Control Number (UB2-12). 872 */ 873 public ST[] getUb212_DocumentControlNumber() { 874 ST[] retVal = this.getTypedField(12, new ST[0]); 875 return retVal; 876 } 877 878 879 /** 880 * Returns a count of the current number of repetitions of Document Control Number (UB2-12). 881 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 882 * it will return zero. 883 */ 884 public int getDocumentControlNumberReps() { 885 return this.getReps(12); 886 } 887 888 889 /** 890 * Returns a specific repetition of 891 * UB2-12: "Document Control Number" - creates it if necessary 892 * 893 * @param rep The repetition index (0-indexed) 894 */ 895 public ST getDocumentControlNumber(int rep) { 896 ST retVal = this.getTypedField(12, rep); 897 return retVal; 898 } 899 900 /** 901 * Returns a specific repetition of 902 * UB2-12: "Document Control Number" - creates it if necessary 903 * 904 * @param rep The repetition index (0-indexed) 905 */ 906 public ST getUb212_DocumentControlNumber(int rep) { 907 ST retVal = this.getTypedField(12, rep); 908 return retVal; 909 } 910 911 /** 912 * Returns a count of the current number of repetitions of Document Control Number (UB2-12). 913 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 914 * it will return zero. 915 */ 916 public int getUb212_DocumentControlNumberReps() { 917 return this.getReps(12); 918 } 919 920 921 /** 922 * Inserts a repetition of 923 * UB2-12: "Document Control Number" at a specific index 924 * 925 * @param rep The repetition index (0-indexed) 926 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 927 */ 928 public ST insertDocumentControlNumber(int rep) throws HL7Exception { 929 return (ST) super.insertRepetition(12, rep); 930 } 931 932 933 /** 934 * Inserts a repetition of 935 * UB2-12: "Document Control Number" at a specific index 936 * 937 * @param rep The repetition index (0-indexed) 938 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 939 */ 940 public ST insertUb212_DocumentControlNumber(int rep) throws HL7Exception { 941 return (ST) super.insertRepetition(12, rep); 942 } 943 944 945 /** 946 * Removes a repetition of 947 * UB2-12: "Document Control Number" 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 ST removeDocumentControlNumber(int rep) throws HL7Exception { 953 return (ST) super.removeRepetition(12, rep); 954 } 955 956 957 /** 958 * Removes a repetition of 959 * UB2-12: "Document Control Number" 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 ST removeUb212_DocumentControlNumber(int rep) throws HL7Exception { 965 return (ST) super.removeRepetition(12, rep); 966 } 967 968 969 970 /** 971 * Returns all repetitions of UB92 Locator 49 (National) (UB2-13). 972 */ 973 public ST[] getUB92Locator49National() { 974 ST[] retVal = this.getTypedField(13, new ST[0]); 975 return retVal; 976 } 977 978 979 /** 980 * Returns all repetitions of UB92 Locator 49 (National) (UB2-13). 981 */ 982 public ST[] getUb213_UB92Locator49National() { 983 ST[] retVal = this.getTypedField(13, new ST[0]); 984 return retVal; 985 } 986 987 988 /** 989 * Returns a count of the current number of repetitions of UB92 Locator 49 (National) (UB2-13). 990 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 991 * it will return zero. 992 */ 993 public int getUB92Locator49NationalReps() { 994 return this.getReps(13); 995 } 996 997 998 /** 999 * Returns a specific repetition of 1000 * UB2-13: "UB92 Locator 49 (National)" - creates it if necessary 1001 * 1002 * @param rep The repetition index (0-indexed) 1003 */ 1004 public ST getUB92Locator49National(int rep) { 1005 ST retVal = this.getTypedField(13, rep); 1006 return retVal; 1007 } 1008 1009 /** 1010 * Returns a specific repetition of 1011 * UB2-13: "UB92 Locator 49 (National)" - creates it if necessary 1012 * 1013 * @param rep The repetition index (0-indexed) 1014 */ 1015 public ST getUb213_UB92Locator49National(int rep) { 1016 ST retVal = this.getTypedField(13, rep); 1017 return retVal; 1018 } 1019 1020 /** 1021 * Returns a count of the current number of repetitions of UB92 Locator 49 (National) (UB2-13). 1022 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1023 * it will return zero. 1024 */ 1025 public int getUb213_UB92Locator49NationalReps() { 1026 return this.getReps(13); 1027 } 1028 1029 1030 /** 1031 * Inserts a repetition of 1032 * UB2-13: "UB92 Locator 49 (National)" at a specific index 1033 * 1034 * @param rep The repetition index (0-indexed) 1035 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1036 */ 1037 public ST insertUB92Locator49National(int rep) throws HL7Exception { 1038 return (ST) super.insertRepetition(13, rep); 1039 } 1040 1041 1042 /** 1043 * Inserts a repetition of 1044 * UB2-13: "UB92 Locator 49 (National)" at a specific index 1045 * 1046 * @param rep The repetition index (0-indexed) 1047 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1048 */ 1049 public ST insertUb213_UB92Locator49National(int rep) throws HL7Exception { 1050 return (ST) super.insertRepetition(13, rep); 1051 } 1052 1053 1054 /** 1055 * Removes a repetition of 1056 * UB2-13: "UB92 Locator 49 (National)" 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 ST removeUB92Locator49National(int rep) throws HL7Exception { 1062 return (ST) super.removeRepetition(13, rep); 1063 } 1064 1065 1066 /** 1067 * Removes a repetition of 1068 * UB2-13: "UB92 Locator 49 (National)" 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 ST removeUb213_UB92Locator49National(int rep) throws HL7Exception { 1074 return (ST) super.removeRepetition(13, rep); 1075 } 1076 1077 1078 1079 /** 1080 * Returns all repetitions of UB92 Locator 56 (State) (UB2-14). 1081 */ 1082 public ST[] getUB92Locator56State() { 1083 ST[] retVal = this.getTypedField(14, new ST[0]); 1084 return retVal; 1085 } 1086 1087 1088 /** 1089 * Returns all repetitions of UB92 Locator 56 (State) (UB2-14). 1090 */ 1091 public ST[] getUb214_UB92Locator56State() { 1092 ST[] retVal = this.getTypedField(14, new ST[0]); 1093 return retVal; 1094 } 1095 1096 1097 /** 1098 * Returns a count of the current number of repetitions of UB92 Locator 56 (State) (UB2-14). 1099 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1100 * it will return zero. 1101 */ 1102 public int getUB92Locator56StateReps() { 1103 return this.getReps(14); 1104 } 1105 1106 1107 /** 1108 * Returns a specific repetition of 1109 * UB2-14: "UB92 Locator 56 (State)" - creates it if necessary 1110 * 1111 * @param rep The repetition index (0-indexed) 1112 */ 1113 public ST getUB92Locator56State(int rep) { 1114 ST retVal = this.getTypedField(14, rep); 1115 return retVal; 1116 } 1117 1118 /** 1119 * Returns a specific repetition of 1120 * UB2-14: "UB92 Locator 56 (State)" - creates it if necessary 1121 * 1122 * @param rep The repetition index (0-indexed) 1123 */ 1124 public ST getUb214_UB92Locator56State(int rep) { 1125 ST retVal = this.getTypedField(14, rep); 1126 return retVal; 1127 } 1128 1129 /** 1130 * Returns a count of the current number of repetitions of UB92 Locator 56 (State) (UB2-14). 1131 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1132 * it will return zero. 1133 */ 1134 public int getUb214_UB92Locator56StateReps() { 1135 return this.getReps(14); 1136 } 1137 1138 1139 /** 1140 * Inserts a repetition of 1141 * UB2-14: "UB92 Locator 56 (State)" at a specific index 1142 * 1143 * @param rep The repetition index (0-indexed) 1144 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1145 */ 1146 public ST insertUB92Locator56State(int rep) throws HL7Exception { 1147 return (ST) super.insertRepetition(14, rep); 1148 } 1149 1150 1151 /** 1152 * Inserts a repetition of 1153 * UB2-14: "UB92 Locator 56 (State)" at a specific index 1154 * 1155 * @param rep The repetition index (0-indexed) 1156 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1157 */ 1158 public ST insertUb214_UB92Locator56State(int rep) throws HL7Exception { 1159 return (ST) super.insertRepetition(14, rep); 1160 } 1161 1162 1163 /** 1164 * Removes a repetition of 1165 * UB2-14: "UB92 Locator 56 (State)" 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 ST removeUB92Locator56State(int rep) throws HL7Exception { 1171 return (ST) super.removeRepetition(14, rep); 1172 } 1173 1174 1175 /** 1176 * Removes a repetition of 1177 * UB2-14: "UB92 Locator 56 (State)" 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 ST removeUb214_UB92Locator56State(int rep) throws HL7Exception { 1183 return (ST) super.removeRepetition(14, rep); 1184 } 1185 1186 1187 1188 1189 /** 1190 * Returns 1191 * UB2-15: "UB92 Locator 57 (National)" - creates it if necessary 1192 */ 1193 public ST getUB92Locator57National() { 1194 ST retVal = this.getTypedField(15, 0); 1195 return retVal; 1196 } 1197 1198 /** 1199 * Returns 1200 * UB2-15: "UB92 Locator 57 (National)" - creates it if necessary 1201 */ 1202 public ST getUb215_UB92Locator57National() { 1203 ST retVal = this.getTypedField(15, 0); 1204 return retVal; 1205 } 1206 1207 1208 /** 1209 * Returns all repetitions of UB92 Locator 78 (State) (UB2-16). 1210 */ 1211 public ST[] getUB92Locator78State() { 1212 ST[] retVal = this.getTypedField(16, new ST[0]); 1213 return retVal; 1214 } 1215 1216 1217 /** 1218 * Returns all repetitions of UB92 Locator 78 (State) (UB2-16). 1219 */ 1220 public ST[] getUb216_UB92Locator78State() { 1221 ST[] retVal = this.getTypedField(16, new ST[0]); 1222 return retVal; 1223 } 1224 1225 1226 /** 1227 * Returns a count of the current number of repetitions of UB92 Locator 78 (State) (UB2-16). 1228 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1229 * it will return zero. 1230 */ 1231 public int getUB92Locator78StateReps() { 1232 return this.getReps(16); 1233 } 1234 1235 1236 /** 1237 * Returns a specific repetition of 1238 * UB2-16: "UB92 Locator 78 (State)" - creates it if necessary 1239 * 1240 * @param rep The repetition index (0-indexed) 1241 */ 1242 public ST getUB92Locator78State(int rep) { 1243 ST retVal = this.getTypedField(16, rep); 1244 return retVal; 1245 } 1246 1247 /** 1248 * Returns a specific repetition of 1249 * UB2-16: "UB92 Locator 78 (State)" - creates it if necessary 1250 * 1251 * @param rep The repetition index (0-indexed) 1252 */ 1253 public ST getUb216_UB92Locator78State(int rep) { 1254 ST retVal = this.getTypedField(16, rep); 1255 return retVal; 1256 } 1257 1258 /** 1259 * Returns a count of the current number of repetitions of UB92 Locator 78 (State) (UB2-16). 1260 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1261 * it will return zero. 1262 */ 1263 public int getUb216_UB92Locator78StateReps() { 1264 return this.getReps(16); 1265 } 1266 1267 1268 /** 1269 * Inserts a repetition of 1270 * UB2-16: "UB92 Locator 78 (State)" at a specific index 1271 * 1272 * @param rep The repetition index (0-indexed) 1273 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1274 */ 1275 public ST insertUB92Locator78State(int rep) throws HL7Exception { 1276 return (ST) super.insertRepetition(16, rep); 1277 } 1278 1279 1280 /** 1281 * Inserts a repetition of 1282 * UB2-16: "UB92 Locator 78 (State)" at a specific index 1283 * 1284 * @param rep The repetition index (0-indexed) 1285 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1286 */ 1287 public ST insertUb216_UB92Locator78State(int rep) throws HL7Exception { 1288 return (ST) super.insertRepetition(16, rep); 1289 } 1290 1291 1292 /** 1293 * Removes a repetition of 1294 * UB2-16: "UB92 Locator 78 (State)" at a specific index 1295 * 1296 * @param rep The repetition index (0-indexed) 1297 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1298 */ 1299 public ST removeUB92Locator78State(int rep) throws HL7Exception { 1300 return (ST) super.removeRepetition(16, rep); 1301 } 1302 1303 1304 /** 1305 * Removes a repetition of 1306 * UB2-16: "UB92 Locator 78 (State)" at a specific index 1307 * 1308 * @param rep The repetition index (0-indexed) 1309 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1310 */ 1311 public ST removeUb216_UB92Locator78State(int rep) throws HL7Exception { 1312 return (ST) super.removeRepetition(16, rep); 1313 } 1314 1315 1316 1317 1318 /** 1319 * Returns 1320 * UB2-17: "Special Visit Count" - creates it if necessary 1321 */ 1322 public NM getSpecialVisitCount() { 1323 NM retVal = this.getTypedField(17, 0); 1324 return retVal; 1325 } 1326 1327 /** 1328 * Returns 1329 * UB2-17: "Special Visit Count" - creates it if necessary 1330 */ 1331 public NM getUb217_SpecialVisitCount() { 1332 NM retVal = this.getTypedField(17, 0); 1333 return retVal; 1334 } 1335 1336 1337 1338 1339 1340 /** {@inheritDoc} */ 1341 protected Type createNewTypeWithoutReflection(int field) { 1342 switch (field) { 1343 case 0: return new SI(getMessage()); 1344 case 1: return new ST(getMessage()); 1345 case 2: return new IS(getMessage(), new Integer( 43 )); 1346 case 3: return new ST(getMessage()); 1347 case 4: return new ST(getMessage()); 1348 case 5: return new UVC(getMessage()); 1349 case 6: return new OCD(getMessage()); 1350 case 7: return new OSP(getMessage()); 1351 case 8: return new ST(getMessage()); 1352 case 9: return new ST(getMessage()); 1353 case 10: return new ST(getMessage()); 1354 case 11: return new ST(getMessage()); 1355 case 12: return new ST(getMessage()); 1356 case 13: return new ST(getMessage()); 1357 case 14: return new ST(getMessage()); 1358 case 15: return new ST(getMessage()); 1359 case 16: return new NM(getMessage()); 1360 default: return null; 1361 } 1362 } 1363 1364 1365 } 1366