1 /** 2 * The contents of this file are subject to the Mozilla Public License Version 1.1 3 * (the "License"); you may not use this file except in compliance with the License. 4 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 5 * Software distributed under the License is distributed on an "AS IS" basis, 6 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 7 * specific language governing rights and limitations under the License. 8 * 9 * 10 * 11 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 12 * 2001. All Rights Reserved. 13 * 14 * Contributor(s): ______________________________________. 15 * 16 * Alternatively, the contents of this file may be used under the terms of the 17 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 18 * applicable instead of those above. If you wish to allow use of your version of this 19 * file only under the terms of the GPL and not to allow others to use your version 20 * of this file under the MPL, indicate your decision by deleting the provisions above 21 * and replace them with the notice and other provisions required by the GPL License. 22 * If you do not delete the provisions above, a recipient may use your version of 23 * this file under either the MPL or the GPL. 24 * 25 */ 26 27 package ca.uhn.hl7v2.model.primitive; 28 29 import ca.uhn.hl7v2.model.DataTypeException; 30 import ca.uhn.hl7v2.model.DataTypeUtil; 31 32 import java.io.Serializable; 33 import java.util.Calendar; 34 import java.util.Date; 35 import java.util.GregorianCalendar; 36 37 /** 38 * <p> 39 * This class contains functionality used by the TS class 40 * in the version 2.3.0, 2.3.1, and 2.4 packages 41 * </p> 42 * 43 * <p> 44 * Note: The class description below has been excerpted from the Hl7 2.4 documentation. Sectional 45 * references made below also refer to the same documentation. 46 * </p> 47 * 48 * <p> 49 * Format: YYYY[MM[DD[HHMM[SS[.S[S[S[S]]]]]]]][+/-ZZZZ]^<degree of precision> 50 * </p> 51 * 52 * <p> 53 * Contains the exact time of an event, including the date and time. The date portion of a time stamp follows the rules of a 54 * date field and the time portion follows the rules of a time field. The time zone (+/-ZZZZ) is represented as +/-HHMM 55 * offset from UTC (formerly Greenwich Mean Time (GMT)), where +0000 or -0000 both represent UTC (without offset). 56 * The specific data representations used in the HL7 encoding rules are compatible with ISO 8824-1987(E). 57 * In prior versions of HL7, an optional second component indicates the degree of precision of the time stamp (Y = year, L 58 * = month, D = day, H = hour, M = minute, S = second). This optional second component is retained only for purposes of 59 * backward compatibility. 60 * </p> 61 * 62 * <p> 63 * By site-specific agreement, YYYYMMDD[HHMM[SS[.S[S[S[S]]]]]][+/-ZZZZ]^<degree of precision> may be used 64 * where backward compatibility must be maintained. 65 * In the current and future versions of HL7, the precision is indicated by limiting the number of digits used, unless the 66 * optional second component is present. Thus, YYYY is used to specify a precision of "year," YYYYMM specifies a 67 * precision of "month," YYYYMMDD specifies a precision of "day," YYYYMMDDHH is used to specify a precision of 68 * "hour," YYYYMMDDHHMM is used to specify a precision of "minute," YYYYMMDDHHMMSS is used to specify a 69 * precision of seconds, and YYYYMMDDHHMMSS.SSSS is used to specify a precision of ten thousandths of a second. 70 * In each of these cases, the time zone is an optional component. Note that if the time zone is not included, the timezone 71 * defaults to that of the local time zone of the sender. Also note that a TS valued field with the HHMM part set to "0000" 72 * represents midnight of the night extending from the previous day to the day given by the YYYYMMDD part (see example 73 * below). Maximum length of the time stamp is 26. 74 * </p> 75 * <p> 76 * Examples: <br/> 77 * |19760704010159-0500|<br/> 78 * 1:01:59 on July 4, 1976 in the Eastern Standard Time zone (USA).<br/> 79 * |19760704010159-0400|<br/> 80 * 1:01:59 on July 4, 1976 in the Eastern Daylight Saving Time zone (USA).<br/> 81 * |198807050000|<br/> 82 * Midnight of the night extending from July 4 to July 5, 1988 in the local time zone of the sender.<br/> 83 * |19880705|<br/> 84 * Same as prior example, but precision extends only to the day. Could be used for a birthdate, if the time of birth is 85 * unknown.<br/> 86 * |19981004010159+0100|<br/> 87 * 1:01:59 on October 4, 1998 in Amsterdam, NL. (Time zone=+0100).<br/> 88 * </p> 89 * <p> 90 * The HL7 Standard strongly recommends that all systems routinely send the time zone offset but does not require it. All 91 * HL7 systems are required to accept the time zone offset, but its implementation is application specific. For many 92 * applications the time of interest is the local time of the sender. For example, an application in the Eastern Standard Time 93 * zone receiving notification of an admission that takes place at 11:00 PM in San Francisco on December 11 would prefer 94 * to treat the admission as having occurred on December 11 rather than advancing the date to December 12. 95 * </p> 96 * <p> 97 * Note: The time zone [+/-ZZZZ], when used, is restricted to legally-defined time zones and is represented in HHMM 98 * format. 99 * </p> 100 * <p> 101 * One exception to this rule would be a clinical system that processed patient data collected in a clinic and a nearby hospital 102 * that happens to be in a different time zone. Such applications may choose to convert the data to a common 103 * representation. Similar concerns apply to the transitions to and from daylight saving time. HL7 supports such requirements 104 * by requiring that the time zone information be present when the information is sent. It does not, however, specify which of 105 * the treatments discussed here will be applied by the receiving system. 106 * </p> 107 * @author Neal Acharya 108 */ 109 110 @SuppressWarnings("serial") 111 public class CommonTS implements Serializable { 112 113 private CommonDT dt; 114 private CommonTM tm; 115 116 /** Creates new ValidTS 117 * zero argument constructor. 118 * Creates an uninitailized TS datatype 119 */ 120 public CommonTS() { 121 } //zero arg constructor 122 123 /** 124 * Constructs a TS object with the given value. 125 * The stored value will be in the following 126 * format YYYY[MM[DD[HHMM[SS[.S[S[S[S]]]]]]]][+/-ZZZZ] 127 */ 128 public CommonTS(String val) throws DataTypeException { 129 this.setValue(val); 130 } //end constructor 131 132 /** 133 * Returns the day as an integer. 134 */ 135 public int getDay() { 136 int day = 0; 137 if (dt != null) { 138 day = dt.getDay(); 139 } //end if 140 return day; 141 } //end method 142 143 /** 144 * Returns the fractional second value as a float. 145 */ 146 public float getFractSecond() { 147 float fractionOfSec = 0; 148 if (tm != null) { 149 fractionOfSec = tm.getFractSecond(); 150 } //end if 151 return fractionOfSec; 152 } //end method 153 154 /** 155 * Returns the GMT offset value as an integer. 156 */ 157 public int getGMTOffset() { 158 int offSet = 0; 159 if (tm != null) { 160 offSet = tm.getGMTOffset(); 161 } //end if 162 return offSet; 163 } //end method 164 165 /** 166 * Returns the hour as an integer. 167 */ 168 public int getHour() { 169 int hour = 0; 170 if (tm != null) { 171 hour = tm.getHour(); 172 } //end if 173 return hour; 174 } //end method 175 176 /** 177 * Returns the minute as an integer. 178 */ 179 public int getMinute() { 180 int minute = 0; 181 if (tm != null) { 182 minute = tm.getMinute(); 183 } //end if 184 return minute; 185 } //end method 186 187 /** 188 * Returns the month as an integer. 189 */ 190 public int getMonth() { 191 int month = 0; 192 if (dt != null) { 193 month = dt.getMonth(); 194 } //end if 195 return month; 196 } //end method 197 198 /** 199 * Returns the second as an integer. 200 */ 201 public int getSecond() { 202 int seconds = 0; 203 if (tm != null) { 204 seconds = tm.getSecond(); 205 } //end if 206 return seconds; 207 } //end method 208 209 /** 210 * Returns the HL7 TS string value. 211 */ 212 public String getValue() { 213 String value = null; 214 if (dt != null) { 215 value = dt.getValue(); 216 } //end if 217 if (tm != null && value != null && !value.equals("")) { 218 if (tm.getValue() != null && !tm.getValue().equals("")) { 219 //here we know we have a delete value or separate date and the time values supplied 220 if (tm.getValue().equals("\"\"") && dt.getValue().equals("\"\"")) { 221 //set value to the delete value ("") 222 value = "\"\""; 223 } 224 else{ 225 //set value to date concatonated with time value 226 value = value + tm.getValue(); 227 } 228 } //end if 229 if (tm.getValue() == null || tm.getValue().equals("")) { 230 //here we know we both have the date and just the time offset value 231 //change the offset value from an integer to a signed string 232 int offset = tm.getGMTOffset(); 233 String offsetStr = ""; 234 if (offset != CommonTM.GMT_OFFSET_NOT_SET_VALUE) { 235 offsetStr = DataTypeUtil.preAppendZeroes(Math.abs(offset), 4); 236 if (tm.getGMTOffset() >= 0) { 237 offsetStr = "+" + offsetStr; 238 } //end if 239 else { 240 offsetStr = "-" + offsetStr; 241 } //end else 242 } 243 value = value + offsetStr; 244 } //end if 245 } //end if 246 return value; 247 } //end method 248 249 /** 250 * Return the value as a calendar object. If the value is null (e.g. no value has 251 * been set), returns null 252 * 253 * @since 1.1 254 */ 255 public Calendar getValueAsCalendar() { 256 if (getValue() == null) { 257 return null; 258 } 259 260 Calendar retVal = tm.getValueAsCalendar(); 261 262 retVal.set(Calendar.YEAR, getYear()); 263 retVal.set(Calendar.MONTH, getMonth() - 1); 264 retVal.set(Calendar.DATE, getDay()); 265 266 return retVal; 267 } 268 269 /** 270 * Return the value as a date objectIf the value is null (e.g. no value has 271 * been set), returns null 272 * 273 * @since 1.1 274 */ 275 public Date getValueAsDate() { 276 if (getValue() == null) { 277 return null; 278 } 279 280 return getValueAsCalendar().getTime(); 281 } 282 283 /** 284 * Returns the year as an integer. 285 */ 286 public int getYear() { 287 int year = 0; 288 if (dt != null) { 289 year = dt.getYear(); 290 } //end if 291 return year; 292 } //end method 293 294 295 /** 296 * This method takes in integer values for the year, month, day, hour 297 * and minute and performs validations, it then sets the value in the object 298 * formatted as an HL7 Time Stamp value with year&month&day&hour&minute precision (YYYYMMDDHHMM). 299 */ 300 public void setDateMinutePrecision(int yr, int mnth, int dy, int hr, int min) throws DataTypeException { 301 try { 302 //set the value of the date object to the input date value 303 this.setDatePrecision(yr, mnth, dy); 304 //create new time object is there isn't one 305 if (tm == null) { 306 tm = new CommonTM(); 307 } 308 //set the value of the time object to the minute precision with the input values 309 tm.setHourMinutePrecision(hr, min); 310 } //end try 311 312 catch (DataTypeException e) { 313 throw e; 314 } //end catch 315 316 catch (Exception e) { 317 throw new DataTypeException(e); 318 } //end catch 319 } //end method 320 321 322 /** 323 * This method takes in integer values for the year and month and day 324 * and performs validations, it then sets the value in the object 325 * formatted as an HL7 Time Stamp value with year&month&day precision (YYYYMMDD). 326 * 327 */ 328 public void setDatePrecision(int yr, int mnth, int dy) throws DataTypeException { 329 try { 330 //create date object if there isn't one 331 if (dt == null) { 332 dt = new CommonDT(); 333 } 334 //set the value of the date object to the input date value 335 dt.setYearMonthDayPrecision(yr, mnth, dy); 336 //clear the time value object 337 tm = null; 338 } //end try 339 340 catch (DataTypeException e) { 341 throw e; 342 } //end catch 343 344 catch (Exception e) { 345 throw new DataTypeException(e); 346 } //end catch 347 } //end method 348 349 /** 350 * This method takes in integer values for the year, month, day, hour, minute, seconds, 351 * and fractional seconds (going to the tenthousandths precision). 352 * The method performs validations and then sets the value in the object formatted as an 353 * HL7 time value with a precision that starts from the year and goes down to the tenthousandths 354 * of a second (YYYYMMDDHHMMSS.SSSS). 355 * The Gmt Offset will not be effected. 356 * Note: all of the precisions from tenths down to 357 * tenthousandths of a second are optional. If the precision goes below tenthousandths 358 * of a second then the second value will be rounded to the nearest tenthousandths of a second. 359 */ 360 public void setDateSecondPrecision(int yr, int mnth, int dy, int hr, int min, float sec) throws DataTypeException { 361 try { 362 //set the value of the date object to the input date value 363 this.setDatePrecision(yr, mnth, dy); 364 //create new time object is there isn't one 365 if (tm == null) { 366 tm = new CommonTM(); 367 } 368 //set the value of the time object to the second precision with the input values 369 tm.setHourMinSecondPrecision(hr, min, sec); 370 } //end try 371 372 catch (DataTypeException e) { 373 throw e; 374 } //end catch 375 376 catch (Exception e) { 377 throw new DataTypeException(e); 378 } //end catch 379 } //end method 380 381 /** 382 * This method takes in the four digit (signed) GMT offset and sets the offset 383 * field 384 */ 385 public void setOffset(int signedOffset) throws DataTypeException { 386 try { 387 //create new time object is there isn't one 388 if (tm == null) { 389 tm = new CommonTM(); 390 } 391 //set the offset value of the time object to the input value 392 tm.setOffset(signedOffset); 393 } 394 395 catch (DataTypeException e) { 396 throw e; 397 } //end catch 398 399 catch (Exception e) { 400 throw new DataTypeException(e); 401 } //end catch 402 } //end method 403 404 /** 405 * Convenience setter which sets the value using a {@link Calendar} object. 406 * Passing in <code>null</code> clears any existing value. 407 * 408 * Note: Sets fields using precision up to the millisecond, including timezone offset 409 * 410 * @param theCalendar The calendar object from which to retrieve values 411 * @since 1.1 412 */ 413 public void setValue(Calendar theCalendar) throws DataTypeException { 414 if (theCalendar == null) { 415 setValue((String)null); 416 return; 417 } 418 419 int yr = theCalendar.get(Calendar.YEAR); 420 int mnth = theCalendar.get(Calendar.MONTH) + 1; 421 int dy = theCalendar.get(Calendar.DATE); 422 int hr = theCalendar.get(Calendar.HOUR_OF_DAY); 423 int min = theCalendar.get(Calendar.MINUTE); 424 float sec = theCalendar.get(Calendar.SECOND) + (theCalendar.get(Calendar.MILLISECOND) / 1000.0F); 425 setDateSecondPrecision(yr, mnth, dy, hr, min, sec); 426 427 // 3410095: care for integer overflow and timezones not at the full hour, e.g. India 428 int timeZoneOffset = theCalendar.get(Calendar.ZONE_OFFSET) + theCalendar.get(Calendar.DST_OFFSET); 429 int hourOffset= timeZoneOffset / (1000 * 60 * 60); 430 int minuteOffset = (timeZoneOffset / (1000 * 60)) % 60; 431 int zoneOffset = hourOffset * 100 + minuteOffset; 432 setOffset(zoneOffset); 433 } 434 435 /** 436 * Convenience setter which sets the value using a {@link Calendar} object. Passing in <code>null</code> clears any existing value. 437 * 438 * Note: Sets fields using precision up to the millisecond, and sets the timezone offset to 439 * the current system offset 440 * 441 * @param theDate The calendar object from which to retrieve values 442 * @since 1.1 443 */ 444 public void setValue(Date theDate) throws DataTypeException { 445 if (theDate == null) { 446 setValue((String)null); 447 return; 448 } 449 450 GregorianCalendar cal = new GregorianCalendar(); 451 cal.setTime(theDate); 452 setValue(cal); 453 } 454 455 /** 456 * This method takes in a string HL7 Time Stamp value and performs validations. 457 * The stored value will be in the following 458 * format YYYY[MM[DD[HHMM[SS[.S[S[S[S]]]]]]]][+/-ZZZZ]. 459 * Note: Trailing zeros supplied in the time value (HHMM[SS[.S[S[S[S]]]]]]) 460 * and GMT offset ([+/-ZZZZ]) will be preserved. 461 * Note: If the GMT offset is not supplied then the local 462 * time zone (using standard time zone format which is not modified for daylight savings) 463 * will be stored as a default. Passing in <code>null</code> clears any existing value. 464 */ 465 public void setValue(String val) throws DataTypeException { 466 if (val != null && !val.equals("") && !val.equals("\"\"")) { 467 try { 468 //check the length of the input value, ensure that it is no less than 469 //8 characters in length 470 if (val.length() < 4) { 471 String msg = "The length of the TS datatype value must be at least 4 characters in length."; 472 throw new DataTypeException(msg); 473 } 474 475 //check the length of the input value, ensure that it is not greater 476 //than 24 characters in length 477 if (val.length() > 24) { 478 String msg = "The length of the TS datatype value must not be more than 24 characters in length."; 479 throw new DataTypeException(msg); 480 } 481 482 //at this point we know that we have a value that should conform to the DT 483 //datatype and possibly a value that should conform to the TM datatype 484 String dateVal = null; 485 String timeVal = null; 486 String timeValLessOffset = null; 487 int sp = val.indexOf("+"); 488 int sm = val.indexOf("-"); 489 int indexOfSign = -1; 490 boolean offsetExists = false; 491 boolean timeValIsOffsetOnly = false; 492 if ((sp != -1) || (sm != -1)) { 493 offsetExists = true; 494 } 495 if (sp != -1) 496 indexOfSign = sp; 497 if (sm != -1) 498 indexOfSign = sm; 499 500 if (!offsetExists) { 501 if (val.length() <= 8) { 502 dateVal = val; 503 } 504 else { 505 //here we know that a time value is present 506 dateVal = val.substring(0, 8); 507 timeVal = val.substring(8); 508 timeValLessOffset = timeVal; 509 } 510 } //offset not exist 511 512 if (offsetExists) { 513 if (indexOfSign > 8) { 514 dateVal = val.substring(0, 8); 515 timeVal = val.substring(8); 516 timeValLessOffset = val.substring(8, indexOfSign); 517 } 518 else { 519 //we know that the time val is simply the offset 520 dateVal = val.substring(0, indexOfSign); 521 timeVal = val.substring(indexOfSign); 522 timeValIsOffsetOnly = true; 523 } 524 } //offset exists 525 526 //create date object 527 dt = new CommonDT(); 528 //set the value of the date object to the input date value 529 dt.setValue(dateVal); 530 //if the offset does not exist and a timevalue does not exist then 531 //we must provide a default offset = to the local time zone 532 if (timeVal == null) { 533 // int defaultOffset = DataTypeUtil.getLocalGMTOffset(); 534 tm = new CommonTM(); 535 //tm.setOffset(defaultOffset); 536 tm.setValue(""); 537 } //end if 538 539 //if we have a time value then make a new time object and set it to the 540 //input time value (as long as the time val has time + offset or just time only) 541 if (timeVal != null && !timeValIsOffsetOnly) { 542 // must make sure that the time component contains both hours 543 // at the very least -- must be at least 2 chars in length. 544 // Note: this changed as of v2.5, before hours AND minutes were required. 545 if (timeValLessOffset.length() < 2) { 546 String msg = 547 "The length of the time component for the TM datatype" 548 + " value does not conform to the allowable format" 549 + " YYYY[MM[DD[HH[MM[SS[.S[S[S[S]]]]]]]]][+/-ZZZZ]."; 550 throw new DataTypeException(msg); 551 } //end if 552 tm = new CommonTM(); 553 tm.setValue(timeVal); 554 } //end if 555 556 //if we have a time value and it only has the offset then make a new 557 //time object and set the offset value to the input value 558 if (timeVal != null && timeValIsOffsetOnly) { 559 //we know that the time value is just the offset so we 560 //must check to see if it is the right length before setting the 561 //offset field in the tm object 562 if (timeVal.length() != 5) { 563 String msg = 564 "The length of the GMT offset for the TM datatype value does" 565 + " not conform to the allowable format [+/-ZZZZ]"; 566 throw new DataTypeException(msg); 567 } //end if 568 tm = new CommonTM(); 569 //first extract the + sign from the offset value string if it exists 570 if (timeVal.indexOf("+") == 0) { 571 timeVal = timeVal.substring(1); 572 } //end if 573 int signedOffset = Integer.parseInt(timeVal); 574 tm.setOffset(signedOffset); 575 } //end if 576 } //end try 577 578 catch (DataTypeException e) { 579 throw e; 580 } //end catch 581 582 catch (Exception e) { 583 throw new DataTypeException(e); 584 } //end catch 585 } //end if 586 else { 587 //set the private value field to null or empty space. 588 if (val == null) { 589 dt = null; 590 tm = null; 591 } //end if 592 if (val != null && val.equals("")) { 593 dt = new CommonDT(); 594 dt.setValue(""); 595 tm = new CommonTM(); 596 tm.setValue(""); 597 } //end if 598 if (val != null && val.equals("\"\"")) { 599 dt = new CommonDT(); 600 dt.setValue("\"\""); 601 tm = new CommonTM(); 602 tm.setValue("\"\""); 603 } //end if 604 } //end else 605 606 } // end method 607 608 /** 609 * Convenience setter which sets the value using a {@link Calendar} object. Passing in <code>null</code> clears any existing value. 610 * 611 * Note: Sets fields using precision up to the minute 612 * 613 * @param theCalendar The calendar object from which to retrieve values 614 * @since 1.1 615 */ 616 public void setValueToMinute(Calendar theCalendar) throws DataTypeException { 617 if (theCalendar == null) { 618 setValue((String)null); 619 return; 620 } 621 622 int yr = theCalendar.get(Calendar.YEAR); 623 int mnth = theCalendar.get(Calendar.MONTH) + 1; 624 int dy = theCalendar.get(Calendar.DATE); 625 int hr = theCalendar.get(Calendar.HOUR_OF_DAY); 626 int min = theCalendar.get(Calendar.MINUTE); 627 setDateMinutePrecision(yr, mnth, dy, hr, min); 628 629 } 630 631 /** 632 * Convenience setter which sets the value using a {@link Date} object. Passing in <code>null</code> clears any existing value. 633 * 634 * Note: Sets fields using precision up to the minute 635 * 636 * @param theDate The date object from which to retrieve values 637 * @since 1.1 638 */ 639 public void setValueToMinute(Date theDate) throws DataTypeException { 640 if (theDate == null) { 641 setValue((String)null); 642 return; 643 } 644 645 Calendar calendar = Calendar.getInstance(); 646 calendar.setTime(theDate); 647 setValueToMinute(calendar); 648 } 649 650 /** 651 * Convenience setter which sets the value using a {@link Calendar} object. Passing in <code>null</code> clears any existing value. 652 * 653 * Note: Sets fields using precision up to the second 654 * 655 * @param theCalendar The calendar object from which to retrieve values 656 * @since 1.1 657 */ 658 public void setValueToSecond(Calendar theCalendar) throws DataTypeException { 659 if (theCalendar == null) { 660 setValue((String)null); 661 return; 662 } 663 664 int yr = theCalendar.get(Calendar.YEAR); 665 int mnth = theCalendar.get(Calendar.MONTH) + 1; 666 int dy = theCalendar.get(Calendar.DATE); 667 int hr = theCalendar.get(Calendar.HOUR_OF_DAY); 668 int min = theCalendar.get(Calendar.MINUTE); 669 int sec = theCalendar.get(Calendar.SECOND); 670 setDateSecondPrecision(yr, mnth, dy, hr, min, sec); 671 } 672 673 /** 674 * Convenience setter which sets the value using a {@link Date} object. Passing in <code>null</code> clears any existing value. 675 * 676 * Note: Sets fields using precision up to the second 677 * 678 * @param theDate The date object from which to retrieve values 679 * @since 1.1 680 */ 681 public void setValueToSecond(Date theDate) throws DataTypeException { 682 if (theDate == null) { 683 setValue((String)null); 684 return; 685 } 686 687 Calendar calendar = Calendar.getInstance(); 688 calendar.setTime(theDate); 689 setValueToSecond(calendar); 690 } 691 692 /** 693 * Returns a string value representing the input Gregorian Calendar object in 694 * an Hl7 TimeStamp Format. 695 */ 696 public static String toHl7TSFormat(GregorianCalendar cal) throws DataTypeException { 697 String val; 698 try { 699 //set the input cal object so that it can report errors 700 //on it's value 701 cal.setLenient(false); 702 int calYear = cal.get(GregorianCalendar.YEAR); 703 int calMonth = cal.get(GregorianCalendar.MONTH) + 1; 704 int calDay = cal.get(GregorianCalendar.DAY_OF_MONTH); 705 int calHour = cal.get(GregorianCalendar.HOUR_OF_DAY); 706 int calMin = cal.get(GregorianCalendar.MINUTE); 707 int calSec = cal.get(GregorianCalendar.SECOND); 708 int calMilli = cal.get(GregorianCalendar.MILLISECOND); 709 //the inputs seconds and milli seconds should be combined into a float type 710 float fractSec = calMilli / 1000F; 711 float calSecFloat = calSec + fractSec; 712 int calOffset = cal.get(GregorianCalendar.ZONE_OFFSET) + cal.get(GregorianCalendar.DST_OFFSET); 713 //Note the input's Offset value is in milliseconds, we must convert it to 714 //a 4 digit integer in the HL7 Offset format. 715 int offSetSignInt; 716 if (calOffset < 0) { 717 offSetSignInt = -1; 718 } 719 else { 720 offSetSignInt = 1; 721 } 722 //get the absolute value of the gmtOffSet 723 int absGmtOffSet = Math.abs(calOffset); 724 int gmtOffSetHours = absGmtOffSet / (3600 * 1000); 725 int gmtOffSetMin = (absGmtOffSet / 60000) % (60); 726 //reset calOffset 727 calOffset = ((gmtOffSetHours * 100) + gmtOffSetMin) * offSetSignInt; 728 //Create an object of the TS class and populate it with the above values 729 //then return the HL7 string value from the object 730 CommonTSitive/CommonTS.html#CommonTS">CommonTS ts = new CommonTS(); 731 ts.setDateSecondPrecision(calYear, calMonth, calDay, calHour, calMin, calSecFloat); 732 ts.setOffset(calOffset); 733 val = ts.getValue(); 734 } // end try 735 736 catch (DataTypeException e) { 737 throw e; 738 } //end catch 739 740 catch (Exception e) { 741 throw new DataTypeException(e); 742 } //end catch 743 return val; 744 } //end method 745 746 747 public static void main(String[] args) throws DataTypeException { 748 749 CommonTS ts = new CommonTS(); 750 ts.setValue("1984"); 751 752 System.out.println(ts.getValue()); 753 754 } 755 756 757 } //end class