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.v25.segment; 035 036// import ca.uhn.hl7v2.model.v25.group.*; 037import ca.uhn.hl7v2.model.v25.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 QRF message segment (Original style query filter). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>QRF-1: Where Subject Filter (ST) <b> repeating</b> 053 * <li>QRF-2: When Data Start Date/Time (TS) <b>optional </b> 054 * <li>QRF-3: When Data End Date/Time (TS) <b>optional </b> 055 * <li>QRF-4: What User Qualifier (ST) <b>optional repeating</b> 056 * <li>QRF-5: Other QRY Subject Filter (ST) <b>optional repeating</b> 057 * <li>QRF-6: Which Date/Time Qualifier (ID) <b>optional repeating</b> 058 * <li>QRF-7: Which Date/Time Status Qualifier (ID) <b>optional repeating</b> 059 * <li>QRF-8: Date/Time Selection Qualifier (ID) <b>optional repeating</b> 060 * <li>QRF-9: When Quantity/Timing Qualifier (TQ) <b>optional </b> 061 * <li>QRF-10: Search Confidence Threshold (NM) <b>optional </b> 062 * </ul> 063 */ 064@SuppressWarnings("unused") 065public class QRF extends AbstractSegment { 066 067 /** 068 * Creates a new QRF segment 069 */ 070 public QRF(Group parent, ModelClassFactory factory) { 071 super(parent, factory); 072 init(factory); 073 } 074 075 private void init(ModelClassFactory factory) { 076 try { 077 this.add(ST.class, true, 0, 20, new Object[]{ getMessage() }, "Where Subject Filter"); 078 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "When Data Start Date/Time"); 079 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "When Data End Date/Time"); 080 this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "What User Qualifier"); 081 this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Other QRY Subject Filter"); 082 this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(156) }, "Which Date/Time Qualifier"); 083 this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(157) }, "Which Date/Time Status Qualifier"); 084 this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(158) }, "Date/Time Selection Qualifier"); 085 this.add(TQ.class, false, 1, 60, new Object[]{ getMessage() }, "When Quantity/Timing Qualifier"); 086 this.add(NM.class, false, 1, 10, new Object[]{ getMessage() }, "Search Confidence Threshold"); 087 } catch(HL7Exception e) { 088 log.error("Unexpected error creating QRF - this is probably a bug in the source code generator.", e); 089 } 090 } 091 092 093 /** 094 * Returns all repetitions of Where Subject Filter (QRF-1). 095 */ 096 public ST[] getWhereSubjectFilter() { 097 ST[] retVal = this.getTypedField(1, new ST[0]); 098 return retVal; 099 } 100 101 102 /** 103 * Returns all repetitions of Where Subject Filter (QRF-1). 104 */ 105 public ST[] getQrf1_WhereSubjectFilter() { 106 ST[] retVal = this.getTypedField(1, new ST[0]); 107 return retVal; 108 } 109 110 111 /** 112 * Returns a count of the current number of repetitions of Where Subject Filter (QRF-1). 113 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 114 * it will return zero. 115 */ 116 public int getWhereSubjectFilterReps() { 117 return this.getReps(1); 118 } 119 120 121 /** 122 * Returns a specific repetition of 123 * QRF-1: "Where Subject Filter" - creates it if necessary 124 * 125 * @param rep The repetition index (0-indexed) 126 */ 127 public ST getWhereSubjectFilter(int rep) { 128 ST retVal = this.getTypedField(1, rep); 129 return retVal; 130 } 131 132 /** 133 * Returns a specific repetition of 134 * QRF-1: "Where Subject Filter" - creates it if necessary 135 * 136 * @param rep The repetition index (0-indexed) 137 */ 138 public ST getQrf1_WhereSubjectFilter(int rep) { 139 ST retVal = this.getTypedField(1, rep); 140 return retVal; 141 } 142 143 /** 144 * Returns a count of the current number of repetitions of Where Subject Filter (QRF-1). 145 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 146 * it will return zero. 147 */ 148 public int getQrf1_WhereSubjectFilterReps() { 149 return this.getReps(1); 150 } 151 152 153 /** 154 * Inserts a repetition of 155 * QRF-1: "Where Subject Filter" at a specific index 156 * 157 * @param rep The repetition index (0-indexed) 158 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 159 */ 160 public ST insertWhereSubjectFilter(int rep) throws HL7Exception { 161 return (ST) super.insertRepetition(1, rep); 162 } 163 164 165 /** 166 * Inserts a repetition of 167 * QRF-1: "Where Subject Filter" at a specific index 168 * 169 * @param rep The repetition index (0-indexed) 170 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 171 */ 172 public ST insertQrf1_WhereSubjectFilter(int rep) throws HL7Exception { 173 return (ST) super.insertRepetition(1, rep); 174 } 175 176 177 /** 178 * Removes a repetition of 179 * QRF-1: "Where Subject Filter" at a specific index 180 * 181 * @param rep The repetition index (0-indexed) 182 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 183 */ 184 public ST removeWhereSubjectFilter(int rep) throws HL7Exception { 185 return (ST) super.removeRepetition(1, rep); 186 } 187 188 189 /** 190 * Removes a repetition of 191 * QRF-1: "Where Subject Filter" at a specific index 192 * 193 * @param rep The repetition index (0-indexed) 194 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 195 */ 196 public ST removeQrf1_WhereSubjectFilter(int rep) throws HL7Exception { 197 return (ST) super.removeRepetition(1, rep); 198 } 199 200 201 202 203 /** 204 * Returns 205 * QRF-2: "When Data Start Date/Time" - creates it if necessary 206 */ 207 public TS getWhenDataStartDateTime() { 208 TS retVal = this.getTypedField(2, 0); 209 return retVal; 210 } 211 212 /** 213 * Returns 214 * QRF-2: "When Data Start Date/Time" - creates it if necessary 215 */ 216 public TS getQrf2_WhenDataStartDateTime() { 217 TS retVal = this.getTypedField(2, 0); 218 return retVal; 219 } 220 221 222 223 /** 224 * Returns 225 * QRF-3: "When Data End Date/Time" - creates it if necessary 226 */ 227 public TS getWhenDataEndDateTime() { 228 TS retVal = this.getTypedField(3, 0); 229 return retVal; 230 } 231 232 /** 233 * Returns 234 * QRF-3: "When Data End Date/Time" - creates it if necessary 235 */ 236 public TS getQrf3_WhenDataEndDateTime() { 237 TS retVal = this.getTypedField(3, 0); 238 return retVal; 239 } 240 241 242 /** 243 * Returns all repetitions of What User Qualifier (QRF-4). 244 */ 245 public ST[] getWhatUserQualifier() { 246 ST[] retVal = this.getTypedField(4, new ST[0]); 247 return retVal; 248 } 249 250 251 /** 252 * Returns all repetitions of What User Qualifier (QRF-4). 253 */ 254 public ST[] getQrf4_WhatUserQualifier() { 255 ST[] retVal = this.getTypedField(4, new ST[0]); 256 return retVal; 257 } 258 259 260 /** 261 * Returns a count of the current number of repetitions of What User Qualifier (QRF-4). 262 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 263 * it will return zero. 264 */ 265 public int getWhatUserQualifierReps() { 266 return this.getReps(4); 267 } 268 269 270 /** 271 * Returns a specific repetition of 272 * QRF-4: "What User Qualifier" - creates it if necessary 273 * 274 * @param rep The repetition index (0-indexed) 275 */ 276 public ST getWhatUserQualifier(int rep) { 277 ST retVal = this.getTypedField(4, rep); 278 return retVal; 279 } 280 281 /** 282 * Returns a specific repetition of 283 * QRF-4: "What User Qualifier" - creates it if necessary 284 * 285 * @param rep The repetition index (0-indexed) 286 */ 287 public ST getQrf4_WhatUserQualifier(int rep) { 288 ST retVal = this.getTypedField(4, rep); 289 return retVal; 290 } 291 292 /** 293 * Returns a count of the current number of repetitions of What User Qualifier (QRF-4). 294 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 295 * it will return zero. 296 */ 297 public int getQrf4_WhatUserQualifierReps() { 298 return this.getReps(4); 299 } 300 301 302 /** 303 * Inserts a repetition of 304 * QRF-4: "What User Qualifier" at a specific index 305 * 306 * @param rep The repetition index (0-indexed) 307 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 308 */ 309 public ST insertWhatUserQualifier(int rep) throws HL7Exception { 310 return (ST) super.insertRepetition(4, rep); 311 } 312 313 314 /** 315 * Inserts a repetition of 316 * QRF-4: "What User Qualifier" at a specific index 317 * 318 * @param rep The repetition index (0-indexed) 319 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 320 */ 321 public ST insertQrf4_WhatUserQualifier(int rep) throws HL7Exception { 322 return (ST) super.insertRepetition(4, rep); 323 } 324 325 326 /** 327 * Removes a repetition of 328 * QRF-4: "What User Qualifier" at a specific index 329 * 330 * @param rep The repetition index (0-indexed) 331 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 332 */ 333 public ST removeWhatUserQualifier(int rep) throws HL7Exception { 334 return (ST) super.removeRepetition(4, rep); 335 } 336 337 338 /** 339 * Removes a repetition of 340 * QRF-4: "What User Qualifier" at a specific index 341 * 342 * @param rep The repetition index (0-indexed) 343 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 344 */ 345 public ST removeQrf4_WhatUserQualifier(int rep) throws HL7Exception { 346 return (ST) super.removeRepetition(4, rep); 347 } 348 349 350 351 /** 352 * Returns all repetitions of Other QRY Subject Filter (QRF-5). 353 */ 354 public ST[] getOtherQRYSubjectFilter() { 355 ST[] retVal = this.getTypedField(5, new ST[0]); 356 return retVal; 357 } 358 359 360 /** 361 * Returns all repetitions of Other QRY Subject Filter (QRF-5). 362 */ 363 public ST[] getQrf5_OtherQRYSubjectFilter() { 364 ST[] retVal = this.getTypedField(5, new ST[0]); 365 return retVal; 366 } 367 368 369 /** 370 * Returns a count of the current number of repetitions of Other QRY Subject Filter (QRF-5). 371 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 372 * it will return zero. 373 */ 374 public int getOtherQRYSubjectFilterReps() { 375 return this.getReps(5); 376 } 377 378 379 /** 380 * Returns a specific repetition of 381 * QRF-5: "Other QRY Subject Filter" - creates it if necessary 382 * 383 * @param rep The repetition index (0-indexed) 384 */ 385 public ST getOtherQRYSubjectFilter(int rep) { 386 ST retVal = this.getTypedField(5, rep); 387 return retVal; 388 } 389 390 /** 391 * Returns a specific repetition of 392 * QRF-5: "Other QRY Subject Filter" - creates it if necessary 393 * 394 * @param rep The repetition index (0-indexed) 395 */ 396 public ST getQrf5_OtherQRYSubjectFilter(int rep) { 397 ST retVal = this.getTypedField(5, rep); 398 return retVal; 399 } 400 401 /** 402 * Returns a count of the current number of repetitions of Other QRY Subject Filter (QRF-5). 403 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 404 * it will return zero. 405 */ 406 public int getQrf5_OtherQRYSubjectFilterReps() { 407 return this.getReps(5); 408 } 409 410 411 /** 412 * Inserts a repetition of 413 * QRF-5: "Other QRY Subject Filter" at a specific index 414 * 415 * @param rep The repetition index (0-indexed) 416 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 417 */ 418 public ST insertOtherQRYSubjectFilter(int rep) throws HL7Exception { 419 return (ST) super.insertRepetition(5, rep); 420 } 421 422 423 /** 424 * Inserts a repetition of 425 * QRF-5: "Other QRY Subject Filter" at a specific index 426 * 427 * @param rep The repetition index (0-indexed) 428 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 429 */ 430 public ST insertQrf5_OtherQRYSubjectFilter(int rep) throws HL7Exception { 431 return (ST) super.insertRepetition(5, rep); 432 } 433 434 435 /** 436 * Removes a repetition of 437 * QRF-5: "Other QRY Subject Filter" at a specific index 438 * 439 * @param rep The repetition index (0-indexed) 440 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 441 */ 442 public ST removeOtherQRYSubjectFilter(int rep) throws HL7Exception { 443 return (ST) super.removeRepetition(5, rep); 444 } 445 446 447 /** 448 * Removes a repetition of 449 * QRF-5: "Other QRY Subject Filter" at a specific index 450 * 451 * @param rep The repetition index (0-indexed) 452 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 453 */ 454 public ST removeQrf5_OtherQRYSubjectFilter(int rep) throws HL7Exception { 455 return (ST) super.removeRepetition(5, rep); 456 } 457 458 459 460 /** 461 * Returns all repetitions of Which Date/Time Qualifier (QRF-6). 462 */ 463 public ID[] getWhichDateTimeQualifier() { 464 ID[] retVal = this.getTypedField(6, new ID[0]); 465 return retVal; 466 } 467 468 469 /** 470 * Returns all repetitions of Which Date/Time Qualifier (QRF-6). 471 */ 472 public ID[] getQrf6_WhichDateTimeQualifier() { 473 ID[] retVal = this.getTypedField(6, new ID[0]); 474 return retVal; 475 } 476 477 478 /** 479 * Returns a count of the current number of repetitions of Which Date/Time Qualifier (QRF-6). 480 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 481 * it will return zero. 482 */ 483 public int getWhichDateTimeQualifierReps() { 484 return this.getReps(6); 485 } 486 487 488 /** 489 * Returns a specific repetition of 490 * QRF-6: "Which Date/Time Qualifier" - creates it if necessary 491 * 492 * @param rep The repetition index (0-indexed) 493 */ 494 public ID getWhichDateTimeQualifier(int rep) { 495 ID retVal = this.getTypedField(6, rep); 496 return retVal; 497 } 498 499 /** 500 * Returns a specific repetition of 501 * QRF-6: "Which Date/Time Qualifier" - creates it if necessary 502 * 503 * @param rep The repetition index (0-indexed) 504 */ 505 public ID getQrf6_WhichDateTimeQualifier(int rep) { 506 ID retVal = this.getTypedField(6, rep); 507 return retVal; 508 } 509 510 /** 511 * Returns a count of the current number of repetitions of Which Date/Time Qualifier (QRF-6). 512 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 513 * it will return zero. 514 */ 515 public int getQrf6_WhichDateTimeQualifierReps() { 516 return this.getReps(6); 517 } 518 519 520 /** 521 * Inserts a repetition of 522 * QRF-6: "Which Date/Time Qualifier" at a specific index 523 * 524 * @param rep The repetition index (0-indexed) 525 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 526 */ 527 public ID insertWhichDateTimeQualifier(int rep) throws HL7Exception { 528 return (ID) super.insertRepetition(6, rep); 529 } 530 531 532 /** 533 * Inserts a repetition of 534 * QRF-6: "Which Date/Time Qualifier" at a specific index 535 * 536 * @param rep The repetition index (0-indexed) 537 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 538 */ 539 public ID insertQrf6_WhichDateTimeQualifier(int rep) throws HL7Exception { 540 return (ID) super.insertRepetition(6, rep); 541 } 542 543 544 /** 545 * Removes a repetition of 546 * QRF-6: "Which Date/Time Qualifier" at a specific index 547 * 548 * @param rep The repetition index (0-indexed) 549 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 550 */ 551 public ID removeWhichDateTimeQualifier(int rep) throws HL7Exception { 552 return (ID) super.removeRepetition(6, rep); 553 } 554 555 556 /** 557 * Removes a repetition of 558 * QRF-6: "Which Date/Time Qualifier" at a specific index 559 * 560 * @param rep The repetition index (0-indexed) 561 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 562 */ 563 public ID removeQrf6_WhichDateTimeQualifier(int rep) throws HL7Exception { 564 return (ID) super.removeRepetition(6, rep); 565 } 566 567 568 569 /** 570 * Returns all repetitions of Which Date/Time Status Qualifier (QRF-7). 571 */ 572 public ID[] getWhichDateTimeStatusQualifier() { 573 ID[] retVal = this.getTypedField(7, new ID[0]); 574 return retVal; 575 } 576 577 578 /** 579 * Returns all repetitions of Which Date/Time Status Qualifier (QRF-7). 580 */ 581 public ID[] getQrf7_WhichDateTimeStatusQualifier() { 582 ID[] retVal = this.getTypedField(7, new ID[0]); 583 return retVal; 584 } 585 586 587 /** 588 * Returns a count of the current number of repetitions of Which Date/Time Status Qualifier (QRF-7). 589 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 590 * it will return zero. 591 */ 592 public int getWhichDateTimeStatusQualifierReps() { 593 return this.getReps(7); 594 } 595 596 597 /** 598 * Returns a specific repetition of 599 * QRF-7: "Which Date/Time Status Qualifier" - creates it if necessary 600 * 601 * @param rep The repetition index (0-indexed) 602 */ 603 public ID getWhichDateTimeStatusQualifier(int rep) { 604 ID retVal = this.getTypedField(7, rep); 605 return retVal; 606 } 607 608 /** 609 * Returns a specific repetition of 610 * QRF-7: "Which Date/Time Status Qualifier" - creates it if necessary 611 * 612 * @param rep The repetition index (0-indexed) 613 */ 614 public ID getQrf7_WhichDateTimeStatusQualifier(int rep) { 615 ID retVal = this.getTypedField(7, rep); 616 return retVal; 617 } 618 619 /** 620 * Returns a count of the current number of repetitions of Which Date/Time Status Qualifier (QRF-7). 621 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 622 * it will return zero. 623 */ 624 public int getQrf7_WhichDateTimeStatusQualifierReps() { 625 return this.getReps(7); 626 } 627 628 629 /** 630 * Inserts a repetition of 631 * QRF-7: "Which Date/Time Status Qualifier" at a specific index 632 * 633 * @param rep The repetition index (0-indexed) 634 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 635 */ 636 public ID insertWhichDateTimeStatusQualifier(int rep) throws HL7Exception { 637 return (ID) super.insertRepetition(7, rep); 638 } 639 640 641 /** 642 * Inserts a repetition of 643 * QRF-7: "Which Date/Time Status Qualifier" at a specific index 644 * 645 * @param rep The repetition index (0-indexed) 646 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 647 */ 648 public ID insertQrf7_WhichDateTimeStatusQualifier(int rep) throws HL7Exception { 649 return (ID) super.insertRepetition(7, rep); 650 } 651 652 653 /** 654 * Removes a repetition of 655 * QRF-7: "Which Date/Time Status Qualifier" at a specific index 656 * 657 * @param rep The repetition index (0-indexed) 658 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 659 */ 660 public ID removeWhichDateTimeStatusQualifier(int rep) throws HL7Exception { 661 return (ID) super.removeRepetition(7, rep); 662 } 663 664 665 /** 666 * Removes a repetition of 667 * QRF-7: "Which Date/Time Status Qualifier" at a specific index 668 * 669 * @param rep The repetition index (0-indexed) 670 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 671 */ 672 public ID removeQrf7_WhichDateTimeStatusQualifier(int rep) throws HL7Exception { 673 return (ID) super.removeRepetition(7, rep); 674 } 675 676 677 678 /** 679 * Returns all repetitions of Date/Time Selection Qualifier (QRF-8). 680 */ 681 public ID[] getDateTimeSelectionQualifier() { 682 ID[] retVal = this.getTypedField(8, new ID[0]); 683 return retVal; 684 } 685 686 687 /** 688 * Returns all repetitions of Date/Time Selection Qualifier (QRF-8). 689 */ 690 public ID[] getQrf8_DateTimeSelectionQualifier() { 691 ID[] retVal = this.getTypedField(8, new ID[0]); 692 return retVal; 693 } 694 695 696 /** 697 * Returns a count of the current number of repetitions of Date/Time Selection Qualifier (QRF-8). 698 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 699 * it will return zero. 700 */ 701 public int getDateTimeSelectionQualifierReps() { 702 return this.getReps(8); 703 } 704 705 706 /** 707 * Returns a specific repetition of 708 * QRF-8: "Date/Time Selection Qualifier" - creates it if necessary 709 * 710 * @param rep The repetition index (0-indexed) 711 */ 712 public ID getDateTimeSelectionQualifier(int rep) { 713 ID retVal = this.getTypedField(8, rep); 714 return retVal; 715 } 716 717 /** 718 * Returns a specific repetition of 719 * QRF-8: "Date/Time Selection Qualifier" - creates it if necessary 720 * 721 * @param rep The repetition index (0-indexed) 722 */ 723 public ID getQrf8_DateTimeSelectionQualifier(int rep) { 724 ID retVal = this.getTypedField(8, rep); 725 return retVal; 726 } 727 728 /** 729 * Returns a count of the current number of repetitions of Date/Time Selection Qualifier (QRF-8). 730 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 731 * it will return zero. 732 */ 733 public int getQrf8_DateTimeSelectionQualifierReps() { 734 return this.getReps(8); 735 } 736 737 738 /** 739 * Inserts a repetition of 740 * QRF-8: "Date/Time Selection Qualifier" at a specific index 741 * 742 * @param rep The repetition index (0-indexed) 743 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 744 */ 745 public ID insertDateTimeSelectionQualifier(int rep) throws HL7Exception { 746 return (ID) super.insertRepetition(8, rep); 747 } 748 749 750 /** 751 * Inserts a repetition of 752 * QRF-8: "Date/Time Selection Qualifier" at a specific index 753 * 754 * @param rep The repetition index (0-indexed) 755 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 756 */ 757 public ID insertQrf8_DateTimeSelectionQualifier(int rep) throws HL7Exception { 758 return (ID) super.insertRepetition(8, rep); 759 } 760 761 762 /** 763 * Removes a repetition of 764 * QRF-8: "Date/Time Selection Qualifier" at a specific index 765 * 766 * @param rep The repetition index (0-indexed) 767 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 768 */ 769 public ID removeDateTimeSelectionQualifier(int rep) throws HL7Exception { 770 return (ID) super.removeRepetition(8, rep); 771 } 772 773 774 /** 775 * Removes a repetition of 776 * QRF-8: "Date/Time Selection Qualifier" at a specific index 777 * 778 * @param rep The repetition index (0-indexed) 779 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 780 */ 781 public ID removeQrf8_DateTimeSelectionQualifier(int rep) throws HL7Exception { 782 return (ID) super.removeRepetition(8, rep); 783 } 784 785 786 787 788 /** 789 * Returns 790 * QRF-9: "When Quantity/Timing Qualifier" - creates it if necessary 791 */ 792 public TQ getWhenQuantityTimingQualifier() { 793 TQ retVal = this.getTypedField(9, 0); 794 return retVal; 795 } 796 797 /** 798 * Returns 799 * QRF-9: "When Quantity/Timing Qualifier" - creates it if necessary 800 */ 801 public TQ getQrf9_WhenQuantityTimingQualifier() { 802 TQ retVal = this.getTypedField(9, 0); 803 return retVal; 804 } 805 806 807 808 /** 809 * Returns 810 * QRF-10: "Search Confidence Threshold" - creates it if necessary 811 */ 812 public NM getSearchConfidenceThreshold() { 813 NM retVal = this.getTypedField(10, 0); 814 return retVal; 815 } 816 817 /** 818 * Returns 819 * QRF-10: "Search Confidence Threshold" - creates it if necessary 820 */ 821 public NM getQrf10_SearchConfidenceThreshold() { 822 NM retVal = this.getTypedField(10, 0); 823 return retVal; 824 } 825 826 827 828 829 830 /** {@inheritDoc} */ 831 protected Type createNewTypeWithoutReflection(int field) { 832 switch (field) { 833 case 0: return new ST(getMessage()); 834 case 1: return new TS(getMessage()); 835 case 2: return new TS(getMessage()); 836 case 3: return new ST(getMessage()); 837 case 4: return new ST(getMessage()); 838 case 5: return new ID(getMessage(), new Integer( 156 )); 839 case 6: return new ID(getMessage(), new Integer( 157 )); 840 case 7: return new ID(getMessage(), new Integer( 158 )); 841 case 8: return new TQ(getMessage()); 842 case 9: return new NM(getMessage()); 843 default: return null; 844 } 845 } 846 847 848} 849