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.v251.segment; 035 036// import ca.uhn.hl7v2.model.v251.group.*; 037import ca.uhn.hl7v2.model.v251.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 TQ1 message segment (Timing/Quantity). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>TQ1-1: Set ID - TQ1 (SI) <b>optional </b> 053 * <li>TQ1-2: Quantity (CQ) <b>optional </b> 054 * <li>TQ1-3: Repeat Pattern (RPT) <b>optional repeating</b> 055 * <li>TQ1-4: Explicit Time (TM) <b>optional repeating</b> 056 * <li>TQ1-5: Relative Time and Units (CQ) <b>optional repeating</b> 057 * <li>TQ1-6: Service Duration (CQ) <b>optional </b> 058 * <li>TQ1-7: Start date/time (TS) <b>optional </b> 059 * <li>TQ1-8: End date/time (TS) <b>optional </b> 060 * <li>TQ1-9: Priority (CWE) <b>optional repeating</b> 061 * <li>TQ1-10: Condition text (TX) <b>optional </b> 062 * <li>TQ1-11: Text instruction (TX) <b>optional </b> 063 * <li>TQ1-12: Conjunction (ID) <b>optional </b> 064 * <li>TQ1-13: Occurrence duration (CQ) <b>optional </b> 065 * <li>TQ1-14: Total occurrence's (NM) <b>optional </b> 066 * </ul> 067 */ 068@SuppressWarnings("unused") 069public class TQ1 extends AbstractSegment { 070 071 /** 072 * Creates a new TQ1 segment 073 */ 074 public TQ1(Group parent, ModelClassFactory factory) { 075 super(parent, factory); 076 init(factory); 077 } 078 079 private void init(ModelClassFactory factory) { 080 try { 081 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - TQ1"); 082 this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Quantity"); 083 this.add(RPT.class, false, 0, 540, new Object[]{ getMessage() }, "Repeat Pattern"); 084 this.add(TM.class, false, 0, 20, new Object[]{ getMessage() }, "Explicit Time"); 085 this.add(CQ.class, false, 0, 20, new Object[]{ getMessage() }, "Relative Time and Units"); 086 this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Service Duration"); 087 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Start date/time"); 088 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "End date/time"); 089 this.add(CWE.class, false, 0, 250, new Object[]{ getMessage() }, "Priority"); 090 this.add(TX.class, false, 1, 250, new Object[]{ getMessage() }, "Condition text"); 091 this.add(TX.class, false, 1, 250, new Object[]{ getMessage() }, "Text instruction"); 092 this.add(ID.class, false, 1, 10, new Object[]{ getMessage(), new Integer(427) }, "Conjunction"); 093 this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Occurrence duration"); 094 this.add(NM.class, false, 1, 10, new Object[]{ getMessage() }, "Total occurrence's"); 095 } catch(HL7Exception e) { 096 log.error("Unexpected error creating TQ1 - this is probably a bug in the source code generator.", e); 097 } 098 } 099 100 101 102 /** 103 * Returns 104 * TQ1-1: "Set ID - TQ1" - creates it if necessary 105 */ 106 public SI getSetIDTQ1() { 107 SI retVal = this.getTypedField(1, 0); 108 return retVal; 109 } 110 111 /** 112 * Returns 113 * TQ1-1: "Set ID - TQ1" - creates it if necessary 114 */ 115 public SI getTq11_SetIDTQ1() { 116 SI retVal = this.getTypedField(1, 0); 117 return retVal; 118 } 119 120 121 122 /** 123 * Returns 124 * TQ1-2: "Quantity" - creates it if necessary 125 */ 126 public CQ getQuantity() { 127 CQ retVal = this.getTypedField(2, 0); 128 return retVal; 129 } 130 131 /** 132 * Returns 133 * TQ1-2: "Quantity" - creates it if necessary 134 */ 135 public CQ getTq12_Quantity() { 136 CQ retVal = this.getTypedField(2, 0); 137 return retVal; 138 } 139 140 141 /** 142 * Returns all repetitions of Repeat Pattern (TQ1-3). 143 */ 144 public RPT[] getRepeatPattern() { 145 RPT[] retVal = this.getTypedField(3, new RPT[0]); 146 return retVal; 147 } 148 149 150 /** 151 * Returns all repetitions of Repeat Pattern (TQ1-3). 152 */ 153 public RPT[] getTq13_RepeatPattern() { 154 RPT[] retVal = this.getTypedField(3, new RPT[0]); 155 return retVal; 156 } 157 158 159 /** 160 * Returns a count of the current number of repetitions of Repeat Pattern (TQ1-3). 161 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 162 * it will return zero. 163 */ 164 public int getRepeatPatternReps() { 165 return this.getReps(3); 166 } 167 168 169 /** 170 * Returns a specific repetition of 171 * TQ1-3: "Repeat Pattern" - creates it if necessary 172 * 173 * @param rep The repetition index (0-indexed) 174 */ 175 public RPT getRepeatPattern(int rep) { 176 RPT retVal = this.getTypedField(3, rep); 177 return retVal; 178 } 179 180 /** 181 * Returns a specific repetition of 182 * TQ1-3: "Repeat Pattern" - creates it if necessary 183 * 184 * @param rep The repetition index (0-indexed) 185 */ 186 public RPT getTq13_RepeatPattern(int rep) { 187 RPT retVal = this.getTypedField(3, rep); 188 return retVal; 189 } 190 191 /** 192 * Returns a count of the current number of repetitions of Repeat Pattern (TQ1-3). 193 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 194 * it will return zero. 195 */ 196 public int getTq13_RepeatPatternReps() { 197 return this.getReps(3); 198 } 199 200 201 /** 202 * Inserts a repetition of 203 * TQ1-3: "Repeat Pattern" at a specific index 204 * 205 * @param rep The repetition index (0-indexed) 206 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 207 */ 208 public RPT insertRepeatPattern(int rep) throws HL7Exception { 209 return (RPT) super.insertRepetition(3, rep); 210 } 211 212 213 /** 214 * Inserts a repetition of 215 * TQ1-3: "Repeat Pattern" at a specific index 216 * 217 * @param rep The repetition index (0-indexed) 218 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 219 */ 220 public RPT insertTq13_RepeatPattern(int rep) throws HL7Exception { 221 return (RPT) super.insertRepetition(3, rep); 222 } 223 224 225 /** 226 * Removes a repetition of 227 * TQ1-3: "Repeat Pattern" at a specific index 228 * 229 * @param rep The repetition index (0-indexed) 230 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 231 */ 232 public RPT removeRepeatPattern(int rep) throws HL7Exception { 233 return (RPT) super.removeRepetition(3, rep); 234 } 235 236 237 /** 238 * Removes a repetition of 239 * TQ1-3: "Repeat Pattern" at a specific index 240 * 241 * @param rep The repetition index (0-indexed) 242 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 243 */ 244 public RPT removeTq13_RepeatPattern(int rep) throws HL7Exception { 245 return (RPT) super.removeRepetition(3, rep); 246 } 247 248 249 250 /** 251 * Returns all repetitions of Explicit Time (TQ1-4). 252 */ 253 public TM[] getExplicitTime() { 254 TM[] retVal = this.getTypedField(4, new TM[0]); 255 return retVal; 256 } 257 258 259 /** 260 * Returns all repetitions of Explicit Time (TQ1-4). 261 */ 262 public TM[] getTq14_ExplicitTime() { 263 TM[] retVal = this.getTypedField(4, new TM[0]); 264 return retVal; 265 } 266 267 268 /** 269 * Returns a count of the current number of repetitions of Explicit Time (TQ1-4). 270 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 271 * it will return zero. 272 */ 273 public int getExplicitTimeReps() { 274 return this.getReps(4); 275 } 276 277 278 /** 279 * Returns a specific repetition of 280 * TQ1-4: "Explicit Time" - creates it if necessary 281 * 282 * @param rep The repetition index (0-indexed) 283 */ 284 public TM getExplicitTime(int rep) { 285 TM retVal = this.getTypedField(4, rep); 286 return retVal; 287 } 288 289 /** 290 * Returns a specific repetition of 291 * TQ1-4: "Explicit Time" - creates it if necessary 292 * 293 * @param rep The repetition index (0-indexed) 294 */ 295 public TM getTq14_ExplicitTime(int rep) { 296 TM retVal = this.getTypedField(4, rep); 297 return retVal; 298 } 299 300 /** 301 * Returns a count of the current number of repetitions of Explicit Time (TQ1-4). 302 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 303 * it will return zero. 304 */ 305 public int getTq14_ExplicitTimeReps() { 306 return this.getReps(4); 307 } 308 309 310 /** 311 * Inserts a repetition of 312 * TQ1-4: "Explicit Time" at a specific index 313 * 314 * @param rep The repetition index (0-indexed) 315 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 316 */ 317 public TM insertExplicitTime(int rep) throws HL7Exception { 318 return (TM) super.insertRepetition(4, rep); 319 } 320 321 322 /** 323 * Inserts a repetition of 324 * TQ1-4: "Explicit Time" at a specific index 325 * 326 * @param rep The repetition index (0-indexed) 327 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 328 */ 329 public TM insertTq14_ExplicitTime(int rep) throws HL7Exception { 330 return (TM) super.insertRepetition(4, rep); 331 } 332 333 334 /** 335 * Removes a repetition of 336 * TQ1-4: "Explicit Time" at a specific index 337 * 338 * @param rep The repetition index (0-indexed) 339 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 340 */ 341 public TM removeExplicitTime(int rep) throws HL7Exception { 342 return (TM) super.removeRepetition(4, rep); 343 } 344 345 346 /** 347 * Removes a repetition of 348 * TQ1-4: "Explicit Time" at a specific index 349 * 350 * @param rep The repetition index (0-indexed) 351 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 352 */ 353 public TM removeTq14_ExplicitTime(int rep) throws HL7Exception { 354 return (TM) super.removeRepetition(4, rep); 355 } 356 357 358 359 /** 360 * Returns all repetitions of Relative Time and Units (TQ1-5). 361 */ 362 public CQ[] getRelativeTimeAndUnits() { 363 CQ[] retVal = this.getTypedField(5, new CQ[0]); 364 return retVal; 365 } 366 367 368 /** 369 * Returns all repetitions of Relative Time and Units (TQ1-5). 370 */ 371 public CQ[] getTq15_RelativeTimeAndUnits() { 372 CQ[] retVal = this.getTypedField(5, new CQ[0]); 373 return retVal; 374 } 375 376 377 /** 378 * Returns a count of the current number of repetitions of Relative Time and Units (TQ1-5). 379 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 380 * it will return zero. 381 */ 382 public int getRelativeTimeAndUnitsReps() { 383 return this.getReps(5); 384 } 385 386 387 /** 388 * Returns a specific repetition of 389 * TQ1-5: "Relative Time and Units" - creates it if necessary 390 * 391 * @param rep The repetition index (0-indexed) 392 */ 393 public CQ getRelativeTimeAndUnits(int rep) { 394 CQ retVal = this.getTypedField(5, rep); 395 return retVal; 396 } 397 398 /** 399 * Returns a specific repetition of 400 * TQ1-5: "Relative Time and Units" - creates it if necessary 401 * 402 * @param rep The repetition index (0-indexed) 403 */ 404 public CQ getTq15_RelativeTimeAndUnits(int rep) { 405 CQ retVal = this.getTypedField(5, rep); 406 return retVal; 407 } 408 409 /** 410 * Returns a count of the current number of repetitions of Relative Time and Units (TQ1-5). 411 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 412 * it will return zero. 413 */ 414 public int getTq15_RelativeTimeAndUnitsReps() { 415 return this.getReps(5); 416 } 417 418 419 /** 420 * Inserts a repetition of 421 * TQ1-5: "Relative Time and Units" at a specific index 422 * 423 * @param rep The repetition index (0-indexed) 424 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 425 */ 426 public CQ insertRelativeTimeAndUnits(int rep) throws HL7Exception { 427 return (CQ) super.insertRepetition(5, rep); 428 } 429 430 431 /** 432 * Inserts a repetition of 433 * TQ1-5: "Relative Time and Units" at a specific index 434 * 435 * @param rep The repetition index (0-indexed) 436 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 437 */ 438 public CQ insertTq15_RelativeTimeAndUnits(int rep) throws HL7Exception { 439 return (CQ) super.insertRepetition(5, rep); 440 } 441 442 443 /** 444 * Removes a repetition of 445 * TQ1-5: "Relative Time and Units" at a specific index 446 * 447 * @param rep The repetition index (0-indexed) 448 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 449 */ 450 public CQ removeRelativeTimeAndUnits(int rep) throws HL7Exception { 451 return (CQ) super.removeRepetition(5, rep); 452 } 453 454 455 /** 456 * Removes a repetition of 457 * TQ1-5: "Relative Time and Units" at a specific index 458 * 459 * @param rep The repetition index (0-indexed) 460 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 461 */ 462 public CQ removeTq15_RelativeTimeAndUnits(int rep) throws HL7Exception { 463 return (CQ) super.removeRepetition(5, rep); 464 } 465 466 467 468 469 /** 470 * Returns 471 * TQ1-6: "Service Duration" - creates it if necessary 472 */ 473 public CQ getServiceDuration() { 474 CQ retVal = this.getTypedField(6, 0); 475 return retVal; 476 } 477 478 /** 479 * Returns 480 * TQ1-6: "Service Duration" - creates it if necessary 481 */ 482 public CQ getTq16_ServiceDuration() { 483 CQ retVal = this.getTypedField(6, 0); 484 return retVal; 485 } 486 487 488 489 /** 490 * Returns 491 * TQ1-7: "Start date/time" - creates it if necessary 492 */ 493 public TS getStartDateTime() { 494 TS retVal = this.getTypedField(7, 0); 495 return retVal; 496 } 497 498 /** 499 * Returns 500 * TQ1-7: "Start date/time" - creates it if necessary 501 */ 502 public TS getTq17_StartDateTime() { 503 TS retVal = this.getTypedField(7, 0); 504 return retVal; 505 } 506 507 508 509 /** 510 * Returns 511 * TQ1-8: "End date/time" - creates it if necessary 512 */ 513 public TS getEndDateTime() { 514 TS retVal = this.getTypedField(8, 0); 515 return retVal; 516 } 517 518 /** 519 * Returns 520 * TQ1-8: "End date/time" - creates it if necessary 521 */ 522 public TS getTq18_EndDateTime() { 523 TS retVal = this.getTypedField(8, 0); 524 return retVal; 525 } 526 527 528 /** 529 * Returns all repetitions of Priority (TQ1-9). 530 */ 531 public CWE[] getPriority() { 532 CWE[] retVal = this.getTypedField(9, new CWE[0]); 533 return retVal; 534 } 535 536 537 /** 538 * Returns all repetitions of Priority (TQ1-9). 539 */ 540 public CWE[] getTq19_Priority() { 541 CWE[] retVal = this.getTypedField(9, new CWE[0]); 542 return retVal; 543 } 544 545 546 /** 547 * Returns a count of the current number of repetitions of Priority (TQ1-9). 548 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 549 * it will return zero. 550 */ 551 public int getPriorityReps() { 552 return this.getReps(9); 553 } 554 555 556 /** 557 * Returns a specific repetition of 558 * TQ1-9: "Priority" - creates it if necessary 559 * 560 * @param rep The repetition index (0-indexed) 561 */ 562 public CWE getPriority(int rep) { 563 CWE retVal = this.getTypedField(9, rep); 564 return retVal; 565 } 566 567 /** 568 * Returns a specific repetition of 569 * TQ1-9: "Priority" - creates it if necessary 570 * 571 * @param rep The repetition index (0-indexed) 572 */ 573 public CWE getTq19_Priority(int rep) { 574 CWE retVal = this.getTypedField(9, rep); 575 return retVal; 576 } 577 578 /** 579 * Returns a count of the current number of repetitions of Priority (TQ1-9). 580 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 581 * it will return zero. 582 */ 583 public int getTq19_PriorityReps() { 584 return this.getReps(9); 585 } 586 587 588 /** 589 * Inserts a repetition of 590 * TQ1-9: "Priority" at a specific index 591 * 592 * @param rep The repetition index (0-indexed) 593 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 594 */ 595 public CWE insertPriority(int rep) throws HL7Exception { 596 return (CWE) super.insertRepetition(9, rep); 597 } 598 599 600 /** 601 * Inserts a repetition of 602 * TQ1-9: "Priority" at a specific index 603 * 604 * @param rep The repetition index (0-indexed) 605 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 606 */ 607 public CWE insertTq19_Priority(int rep) throws HL7Exception { 608 return (CWE) super.insertRepetition(9, rep); 609 } 610 611 612 /** 613 * Removes a repetition of 614 * TQ1-9: "Priority" at a specific index 615 * 616 * @param rep The repetition index (0-indexed) 617 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 618 */ 619 public CWE removePriority(int rep) throws HL7Exception { 620 return (CWE) super.removeRepetition(9, rep); 621 } 622 623 624 /** 625 * Removes a repetition of 626 * TQ1-9: "Priority" at a specific index 627 * 628 * @param rep The repetition index (0-indexed) 629 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 630 */ 631 public CWE removeTq19_Priority(int rep) throws HL7Exception { 632 return (CWE) super.removeRepetition(9, rep); 633 } 634 635 636 637 638 /** 639 * Returns 640 * TQ1-10: "Condition text" - creates it if necessary 641 */ 642 public TX getConditionText() { 643 TX retVal = this.getTypedField(10, 0); 644 return retVal; 645 } 646 647 /** 648 * Returns 649 * TQ1-10: "Condition text" - creates it if necessary 650 */ 651 public TX getTq110_ConditionText() { 652 TX retVal = this.getTypedField(10, 0); 653 return retVal; 654 } 655 656 657 658 /** 659 * Returns 660 * TQ1-11: "Text instruction" - creates it if necessary 661 */ 662 public TX getTextInstruction() { 663 TX retVal = this.getTypedField(11, 0); 664 return retVal; 665 } 666 667 /** 668 * Returns 669 * TQ1-11: "Text instruction" - creates it if necessary 670 */ 671 public TX getTq111_TextInstruction() { 672 TX retVal = this.getTypedField(11, 0); 673 return retVal; 674 } 675 676 677 678 /** 679 * Returns 680 * TQ1-12: "Conjunction" - creates it if necessary 681 */ 682 public ID getConjunction() { 683 ID retVal = this.getTypedField(12, 0); 684 return retVal; 685 } 686 687 /** 688 * Returns 689 * TQ1-12: "Conjunction" - creates it if necessary 690 */ 691 public ID getTq112_Conjunction() { 692 ID retVal = this.getTypedField(12, 0); 693 return retVal; 694 } 695 696 697 698 /** 699 * Returns 700 * TQ1-13: "Occurrence duration" - creates it if necessary 701 */ 702 public CQ getOccurrenceDuration() { 703 CQ retVal = this.getTypedField(13, 0); 704 return retVal; 705 } 706 707 /** 708 * Returns 709 * TQ1-13: "Occurrence duration" - creates it if necessary 710 */ 711 public CQ getTq113_OccurrenceDuration() { 712 CQ retVal = this.getTypedField(13, 0); 713 return retVal; 714 } 715 716 717 718 /** 719 * Returns 720 * TQ1-14: "Total occurrence's" - creates it if necessary 721 */ 722 public NM getTotalOccurrenceS() { 723 NM retVal = this.getTypedField(14, 0); 724 return retVal; 725 } 726 727 /** 728 * Returns 729 * TQ1-14: "Total occurrence's" - creates it if necessary 730 */ 731 public NM getTq114_TotalOccurrenceS() { 732 NM retVal = this.getTypedField(14, 0); 733 return retVal; 734 } 735 736 737 738 739 740 /** {@inheritDoc} */ 741 protected Type createNewTypeWithoutReflection(int field) { 742 switch (field) { 743 case 0: return new SI(getMessage()); 744 case 1: return new CQ(getMessage()); 745 case 2: return new RPT(getMessage()); 746 case 3: return new TM(getMessage()); 747 case 4: return new CQ(getMessage()); 748 case 5: return new CQ(getMessage()); 749 case 6: return new TS(getMessage()); 750 case 7: return new TS(getMessage()); 751 case 8: return new CWE(getMessage()); 752 case 9: return new TX(getMessage()); 753 case 10: return new TX(getMessage()); 754 case 11: return new ID(getMessage(), new Integer( 427 )); 755 case 12: return new CQ(getMessage()); 756 case 13: return new NM(getMessage()); 757 default: return null; 758 } 759 } 760 761 762} 763