TimeComponents.java
/* Copyright 2002-2015 CS Systèmes d'Information
* Licensed to CS Systèmes d'Information (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* CS licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.orekit.time;
import java.io.Serializable;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.math3.util.FastMath;
import org.orekit.errors.OrekitException;
import org.orekit.errors.OrekitMessages;
/** Class representing a time within the day broken up as hour,
* minute and second components.
* <p>Instances of this class are guaranteed to be immutable.</p>
* @see DateComponents
* @see DateTimeComponents
* @author Luc Maisonobe
*/
public class TimeComponents implements Serializable, Comparable<TimeComponents> {
/** Constant for commonly used hour 00:00:00. */
public static final TimeComponents H00 = new TimeComponents(0, 0, 0);
/** Constant for commonly used hour 12:00:00. */
public static final TimeComponents H12 = new TimeComponents(12, 0, 0);
/** Serializable UID. */
private static final long serialVersionUID = -8566834296299377436L;
/** Format for hours and minutes. */
private static final DecimalFormat TWO_DIGITS = new DecimalFormat("00");
/** Format for seconds. */
private static final DecimalFormat SECONDS_FORMAT =
new DecimalFormat("00.000", new DecimalFormatSymbols(Locale.US));
/** Basic and extends formats for local time, UTC time (only 0 difference with UTC is supported). */
private static Pattern ISO8601_FORMATS = Pattern.compile("^(\\d\\d):?(\\d\\d):?(\\d\\d(?:[.,]\\d+)?)?(?:Z|[-+]00(?::00)?)?$");
/** Hour number. */
private final int hour;
/** Minute number. */
private final int minute;
/** Second number. */
private final double second;
/** Build a time from its clock elements.
* <p>Note that seconds between 60.0 (inclusive) and 61.0 (exclusive) are allowed
* in this method, since they do occur during leap seconds introduction
* in the {@link UTCScale UTC} time scale.</p>
* @param hour hour number from 0 to 23
* @param minute minute number from 0 to 59
* @param second second number from 0.0 to 61.0 (excluded)
* @exception IllegalArgumentException if inconsistent arguments
* are given (parameters out of range)
*/
public TimeComponents(final int hour, final int minute, final double second)
throws IllegalArgumentException {
// range check
if ((hour < 0) || (hour > 23) ||
(minute < 0) || (minute > 59) ||
(second < 0) || (second >= 61.0)) {
throw OrekitException.createIllegalArgumentException(OrekitMessages.NON_EXISTENT_HMS_TIME,
hour, minute, second);
}
this.hour = hour;
this.minute = minute;
this.second = second;
}
/** Build a time from the second number within the day.
* @param secondInDay second number from 0.0 to {@link
* org.orekit.utils.Constants#JULIAN_DAY} (excluded)
* @exception IllegalArgumentException if seconds number is out of range
*/
public TimeComponents(final double secondInDay) {
this(0, secondInDay);
}
/** Build a time from the second number within the day.
* <p>
* The second number is defined here as the sum
* {@code secondInDayA + secondInDayB} from 0.0 to {@link
* org.orekit.utils.Constants#JULIAN_DAY} (excluded). The two parameters
* are used for increased accuracy.
* </p>
* @param secondInDayA first part of the second number
* @param secondInDayB last part of the second number
* @exception IllegalArgumentException if seconds number is out of range
*/
public TimeComponents(final int secondInDayA, final double secondInDayB) {
// split the numbers as a whole number of seconds
// and a fractional part between 0.0 (included) and 1.0 (excluded)
final int carry = (int) FastMath.floor(secondInDayB);
int wholeSeconds = secondInDayA + carry;
final double fractional = secondInDayB - carry;
// range check
if (wholeSeconds < 0 || wholeSeconds > 86400) {
// beware, 86400 must be allowed to cope with leap seconds introduction days
throw OrekitException.createIllegalArgumentException(OrekitMessages.OUT_OF_RANGE_SECONDS_NUMBER,
wholeSeconds);
}
// extract the time components
hour = wholeSeconds / 3600;
wholeSeconds -= 3600 * hour;
minute = wholeSeconds / 60;
wholeSeconds -= 60 * minute;
second = wholeSeconds + fractional;
}
/** Parse a string in ISO-8601 format to build a time.
* <p>The supported formats are:
* <ul>
* <li>basic format local time: hhmmss (with optional decimals in seconds)</li>
* <li>extended format local time: hh:mm:ss (with optional decimals in seconds)</li>
* <li>basic format UTC time: hhmmssZ (with optional decimals in seconds)</li>
* <li>extended format UTC time: hh:mm:ssZ (with optional decimals in seconds)</li>
* <li>basic format local time with 00h UTC offset: hhmmss+00 (with optional decimals in seconds)</li>
* <li>extended format local time with 00h UTC offset: hhmmss+00 (with optional decimals in seconds)</li>
* <li>basic format local time with 00h and 00m UTC offset: hhmmss+00:00 (with optional decimals in seconds)</li>
* <li>extended format local time with 00h and 00m UTC offset: hhmmss+00:00 (with optional decimals in seconds)</li>
* </ul>
* As shown by the list above, only the complete representations defined in section 4.2
* of ISO-8601 standard are supported, neither expended representations nor representations
* with reduced accuracy are supported.
* </p>
* <p>As this class does not support time zones (because space flight dynamics uses {@link
* TimeScale time scales} with offsets from UTC having sub-second accuracy), only UTC is zone is
* supported (and in fact ignored). It is the responsibility of the {@link AbsoluteDate} class to
* handle time scales appropriately.</p>
* @param string string to parse
* @return a parsed time
* @exception IllegalArgumentException if string cannot be parsed
*/
public static TimeComponents parseTime(final String string) {
// is the date a calendar date ?
final Matcher timeMatcher = ISO8601_FORMATS.matcher(string);
if (timeMatcher.matches()) {
return new TimeComponents(Integer.parseInt(timeMatcher.group(1)),
Integer.parseInt(timeMatcher.group(2)),
Double.parseDouble(timeMatcher.group(3).replace(',', '.')));
}
throw OrekitException.createIllegalArgumentException(OrekitMessages.NON_EXISTENT_TIME, string);
}
/** Get the hour number.
* @return hour number from 0 to 23
*/
public int getHour() {
return hour;
}
/** Get the minute number.
* @return minute minute number from 0 to 59
*/
public int getMinute() {
return minute;
}
/** Get the seconds number.
* @return second second number from 0.0 to 60.0 (excluded)
*/
public double getSecond() {
return second;
}
/** Get the second number within the day.
* @return second number from 0.0 to Constants.JULIAN_DAY
*/
public double getSecondsInDay() {
return second + 60 * minute + 3600 * hour;
}
/** Get a string representation of the time.
* @return string representation of the time
*/
public String toString() {
return new StringBuffer().
append(TWO_DIGITS.format(hour)).append(':').
append(TWO_DIGITS.format(minute)).append(':').
append(SECONDS_FORMAT.format(second)).
toString();
}
/** {@inheritDoc} */
public int compareTo(final TimeComponents other) {
final double seconds = getSecondsInDay();
final double otherSeconds = other.getSecondsInDay();
if (seconds < otherSeconds) {
return -1;
} else if (seconds > otherSeconds) {
return 1;
}
return 0;
}
/** {@inheritDoc} */
public boolean equals(final Object other) {
try {
final TimeComponents otherTime = (TimeComponents) other;
return (otherTime != null) && (hour == otherTime.hour) &&
(minute == otherTime.minute) && (second == otherTime.second);
} catch (ClassCastException cce) {
return false;
}
}
/** {@inheritDoc} */
public int hashCode() {
final long bits = Double.doubleToLongBits(second);
return ((hour << 16) ^ (minute << 8)) ^ (int) (bits ^ (bits >>> 32));
}
}