TimeUtil

java.lang.Object
- org.das2.datum.TimeUtil

public final class TimeUtil
extends java.lang.Object

Various time utilities

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class TimeUtil.TimeDigit

static class TimeUtil.TimeStruct

Nested Classes
Modifier and Type	Class and Description
`static class`	`TimeUtil.TimeDigit`
`static class`	`TimeUtil.TimeStruct`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DAY`
`static int`	`HALF_YEAR`
`static int`	`HOUR`
`static int`	`MICRO`
`static int`	`MILLI`
`static int`	`MINUTE`
`static int`	`MONTH`
`static int`	`NANO`
`static int`	`QUARTER`
`static int`	`SECOND`
`static TimeUtil.TimeDigit`	`TD_DAY`
`static TimeUtil.TimeDigit`	`TD_HOUR`
`static TimeUtil.TimeDigit`	`TD_MICRO`
`static TimeUtil.TimeDigit`	`TD_MILLI`
`static TimeUtil.TimeDigit`	`TD_MINUTE`
`static TimeUtil.TimeDigit`	`TD_MONTH`
`static TimeUtil.TimeDigit`	`TD_NANO`
`static TimeUtil.TimeDigit`	`TD_SECOND`
`static TimeUtil.TimeDigit`	`TD_YEAR`
`static int`	`WEEK`
`static int`	`YEAR`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static TimeUtil.TimeStruct`	`add(TimeUtil.TimeStruct a, TimeUtil.TimeStruct b)`
`static TimeUtil.TimeStruct`	`borrow(TimeUtil.TimeStruct t)` Normalize the TimeStruct by decrementing higher digits.
`static TimeUtil.TimeStruct`	`carry(TimeUtil.TimeStruct t)` Normalize the TimeStruct by incrementing higher digits.
`static Datum`	`ceil(int step, Datum datum)` return the next ordinal boundary if we aren't at one already.
`static double`	`convert(int year, int month, int day, int hour, int minute, double second, TimeLocationUnits units)` convert the month components to a double in the given units.
`static Datum`	`create(java.lang.String s)` Creates a datum from a string
`static Datum`	`createTimeDatum(int year, int month, int day, int hour, int minute, int second, int nano)` creates a Datum representing the time given in integer years, months, ..., seconds, nanoseconds.
`static Datum`	`createValid(java.lang.String validString)` creates a Datum from a string which is known to contain a valid time format.
`static DatumRange`	`dayContaining(Datum t)` return a DatumRange for the day containing the given time.
`static int`	`dayOfYear(int month, int day, int year)` return the day of year for the month and day, for the given year
`static int`	`daysInMonth(int month, int year)`
`static Datum`	`floor(int step, Datum datum)` return the previous ordinal boundary if we aren't at one already.
`static int[]`	`fromDatum(Datum time)` returns the 7-element array of components from the time location datum: 0:year, 1:month, 2:day, 3:hour, 4:minute, 5:second, 6:nanoseconds Note special care is taken to not use units conversions which introduce noise into the numbers, so the following units are handled directly: cdfTT2000, cdfEpoch, us2000, and mj1958.
`static int`	`getJulianDay(Datum datum)` return the the integer number of days that have elapsed since roughly Monday, January 1, 4713 BC.
`static int`	`getJulianDay(long val, Units units)` return the the integer number of days that have elapsed since roughly Monday, January 1, 4713 BC.
`static double`	`getMicroSecondsSinceMidnight(Datum datum)` return the number of microseconds elapsed since the last midnight.
`static double`	`getSecondsSinceMidnight(Datum datum)` return the number of seconds elapsed since the last midnight.
`static boolean`	`isLeapYear(int year)` return the leap year for years 1901-2099.
`static boolean`	`isValidTime(java.lang.String string)` check to see if the string is parseable as a time.
`static int`	`julianDay(int year, int month, int day)` return the julianDay for the year month and day.
`static int`	`julianDayIMCCE(int YY, int MM, int DD)` calculation of julianDay based on http://www.imcce.fr/en/grandpublic/temps/jour_julien.php This is slightly slower because of a cusp at 1582, but is accurate before these times.
`static TimeUtil.TimeStruct`	`julianToGregorian(int julian)` Break the Julian day apart into month, day year.
`static Datum`	`lastLeapSecond(Datum t)` returns the instant after the last leap second.
`static void`	`main(java.lang.String[] args)`
`static java.lang.String`	`monthNameAbbrev(int mon)` returns "Jan", "Feb", ...
`static int`	`monthNumber(java.lang.String s)` returns 1..12 for the English month name.
`static Datum`	`next(int step, Datum datum)` step to the next ordinal.
`static Datum`	`next(TimeUtil.TimeDigit td, int count, Datum datum)` return the next boundary
`static Datum`	`nextMidnight(Datum datum)` provide the next midnight, similar to the ceil function, noting that if the datum provided is midnight already then it is simply returned.
`static Datum`	`nextMonth(Datum datum)` Deprecated. Use next(MONTH,datum) instead
`static TimeUtil.TimeStruct`	`normalize(TimeUtil.TimeStruct t)` convert times like "2000-01-01T24:00" to "2000-01-02T00:00" and "2000-002T00:00" to "2000-01-02T00:00".
`static Datum`	`now()` return the current time as a Datum.
`static TimeUtil.TimeStruct`	`parseTime(java.lang.String s)` parse the time into a timestruct.
`static Datum`	`prev(int step, Datum datum)` step down the previous ordinal.
`static Datum`	`prevMidnight(Datum datum)` provide the previous midnight, similar to the floor function, noting that if the datum provided is midnight exactly then it is simply returned.
`static Datum`	`prevWeek(Datum datum)` decrement by 7 days.
`static DatumRange`	`rangeContaining(int count, int step, Datum t)` return the hour or minute or day
`static DatumRange`	`rangeContaining(int count, int step, DatumRange tr)` return the hours or minutes or days interval containing the time range, or multiple spans of this when the given range spans boundaries.
`static TimeUtil.TimeStruct`	`roundNDigits(TimeUtil.TimeStruct ts, int n)` round seconds to N decimal places.
`static TimeUtil.TimeStruct`	`subtract(TimeUtil.TimeStruct a, TimeUtil.TimeStruct b)`
`static Datum`	`toDatum(int[] timeArray)` get the datum from the 6 or 7 element timeArray.
`static Datum`	`toDatum(int[] timeArray, Units u)` get the time datum from the 6 or 7 element decomposed timeArray.
`static Datum`	`toDatum(TimeUtil.TimeStruct d)` convert to Datum without regard to the type of unit used to represent time.
`static Datum`	`toDatum(TimeUtil.TimeStruct d, Units u)` convert to a Datum with the given units.
`static Datum`	`toDatumDuration(int[] timeArray)` return approximate duration in Units.seconds or in Units.days.
`static int[]`	`toTimeArray(Datum time)` Deprecated. use 7-element fromDatum instead, which is consistent with toDatum. Note the array elements are different!
`static TimeUtil.TimeStruct`	`toTimeStruct(Datum.Long datum)` splits the time location datum into y,m,d,etc components, using the full precision of the Long backing the Datum.
`static TimeUtil.TimeStruct`	`toTimeStruct(Datum datum)` splits the time location datum into y,m,d,etc components.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - YEAR
```
public static final int YEAR
```
    See Also:
    
    Constant Field Values
  - MONTH
```
public static final int MONTH
```
    See Also:
    
    Constant Field Values
  - DAY
```
public static final int DAY
```
    See Also:
    
    Constant Field Values
  - HOUR
```
public static final int HOUR
```
    See Also:
    
    Constant Field Values
  - MINUTE
```
public static final int MINUTE
```
    See Also:
    
    Constant Field Values
  - SECOND
```
public static final int SECOND
```
    See Also:
    
    Constant Field Values
  - MILLI
```
public static final int MILLI
```
    See Also:
    
    Constant Field Values
  - MICRO
```
public static final int MICRO
```
    See Also:
    
    Constant Field Values
  - NANO
```
public static final int NANO
```
    See Also:
    
    Constant Field Values
  - WEEK
```
public static final int WEEK
```
    See Also:
    
    Constant Field Values
  - QUARTER
```
public static final int QUARTER
```
    See Also:
    
    Constant Field Values
  - HALF_YEAR
```
public static final int HALF_YEAR
```
    See Also:
    
    Constant Field Values
  - TD_YEAR
```
public static final TimeUtil.TimeDigit TD_YEAR
```
  - TD_MONTH
```
public static final TimeUtil.TimeDigit TD_MONTH
```
  - TD_DAY
```
public static final TimeUtil.TimeDigit TD_DAY
```
  - TD_HOUR
```
public static final TimeUtil.TimeDigit TD_HOUR
```
  - TD_MINUTE
```
public static final TimeUtil.TimeDigit TD_MINUTE
```
  - TD_SECOND
```
public static final TimeUtil.TimeDigit TD_SECOND
```
  - TD_MILLI
```
public static final TimeUtil.TimeDigit TD_MILLI
```
  - TD_MICRO
```
public static final TimeUtil.TimeDigit TD_MICRO
```
  - TD_NANO
```
public static final TimeUtil.TimeDigit TD_NANO
```
- Method Detail
  - daysInMonth
```
public static int daysInMonth(int month,
                              int year)
```
  - julianDayIMCCE
```
public static int julianDayIMCCE(int YY,
                                 int MM,
                                 int DD)
```
    calculation of julianDay based on http://www.imcce.fr/en/grandpublic/temps/jour_julien.php This is slightly slower because of a cusp at 1582, but is accurate before these times.
    
    Parameters:
    
    YY - Gregorian year
    
    MM - Gregorian month
    
    DD - Gregorian day
    
    Returns:
  - julianDay
```
public static int julianDay(int year,
                            int month,
                            int day)
```
    return the julianDay for the year month and day. This was verified against another calculation (julianDayWP, commented out above) from http://en.wikipedia.org/wiki/Julian_day. Both calculations have 20 operations. Note this does not match
    
    Parameters:
    
    year - calendar year greater than 1582.
    
    month -
    
    day - day of month. For day of year, use month=1 and doy for day.
    
    Returns:
    
    the Julian day
    
    See Also:
    
    julianToGregorian
  - dayOfYear
```
public static int dayOfYear(int month,
                            int day,
                            int year)
```
    return the day of year for the month and day, for the given year
    
    Parameters:
    
    month - the month, january=1, february=2, etc.
    
    day - day of month
    
    year - four-digit year
    
    Returns:
    
    the day of year
  - getSecondsSinceMidnight
```
public static double getSecondsSinceMidnight(Datum datum)
```
    return the number of seconds elapsed since the last midnight.
    
    Parameters:
    
    datum -
    
    Returns:
  - getMicroSecondsSinceMidnight
```
public static double getMicroSecondsSinceMidnight(Datum datum)
```
    return the number of microseconds elapsed since the last midnight.
    
    Parameters:
    
    datum -
    
    Returns:
  - getJulianDay
```
public static int getJulianDay(Datum datum)
```
    return the the integer number of days that have elapsed since roughly Monday, January 1, 4713 BC. Julian Day is defined as starting at noon UT, here is is defined starting at midnight.
    
    Parameters:
    
    datum -
    
    Returns:
  - getJulianDay
```
public static int getJulianDay(long val,
                               Units units)
```
    return the the integer number of days that have elapsed since roughly Monday, January 1, 4713 BC. Julian Day is defined as starting at noon UT, here is is defined starting at midnight.
    
    Parameters:
    
    val - the magnitude
    
    units - Units object identifying the units of the val, such as Units.us2000.
    
    Returns:
  - toDatum
```
public static Datum toDatum(TimeUtil.TimeStruct d)
```
    convert to Datum without regard to the type of unit used to represent time. This will use the canonical Units.us2000 for time locations, which does not represent leap seconds.
    
    Parameters:
    
    d - the decomposed time or time width.
    
    Returns:
    
    the Datum.
  - toDatum
```
public static Datum toDatum(TimeUtil.TimeStruct d,
                            Units u)
```
    convert to a Datum with the given units.
    
    Parameters:
    
    d - the decomposed time
    
    u - the target units.
    
    Returns:
    
    the Datum in the units specified.
  - julianToGregorian
```
public static TimeUtil.TimeStruct julianToGregorian(int julian)
```
    Break the Julian day apart into month, day year. This is based on http://en.wikipedia.org/wiki/Julian_day (GNU Public License), and was introduced when toTimeStruct failed when the year was 1886.
    
    Parameters:
    
    julian - the (integer) number of days that have elapsed since the initial epoch at noon Universal Time (UT) Monday, January 1, 4713 BC
    
    Returns:
    
    a TimeStruct with the month, day and year fields set.
    
    See Also:
    
    julianDay( int year, int mon, int day )
  - toTimeStruct
```
public static TimeUtil.TimeStruct toTimeStruct(Datum.Long datum)
```
    splits the time location datum into y,m,d,etc components, using the full precision of the Long backing the Datum. The datum can have the units of ms1970 or cdf_tt2000, and
    
    Parameters:
    
    datum - with time location units.
    
    Returns:
    
    TimeStruct containing the time components.
  - toTimeStruct
```
public static TimeUtil.TimeStruct toTimeStruct(Datum datum)
```
    splits the time location datum into y,m,d,etc components. Note that if seconds is a double, and micros will be 0.
    
    Parameters:
    
    datum - with time location units.
    
    Returns:
    
    TimeStruct containing the time components.
  - add
```
public static TimeUtil.TimeStruct add(TimeUtil.TimeStruct a,
                                      TimeUtil.TimeStruct b)
```
  - subtract
```
public static TimeUtil.TimeStruct subtract(TimeUtil.TimeStruct a,
                                           TimeUtil.TimeStruct b)
```
  - toTimeArray
```
public static int[] toTimeArray(Datum time)
```
    Deprecated. use 7-element fromDatum instead, which is consistent with toDatum. Note the array elements are different!
    
    returns int[] { year, month, day, hour, minute, second, millis, micros }
    
    Parameters:
    
    time - the time
    
    Returns:
    
    the time decomposed into year, month, day, hour, minute, second, millis, micros.
  - lastLeapSecond
```
public static Datum lastLeapSecond(Datum t)
```
    returns the instant after the last leap second. So for example, lastLeapSecond(datum('2020-01-01T00:00')) → datum('2017-01-01T00:00Z') This code is introduced only to provide some transparency to leap second handling. Note that leap seconds before 1970-01-01 are not supported. Note that most time units do not include leap seconds, so TimeUtil.lastLeapSecond(datum('2016-12-31T23:60Z')) uses us2000 internally and the result is 2017-01-01T00:00Z, not 2015-01-01T00:00Z as one might expect.
    
    Parameters:
    
    t - a time after 1970-01-01
    
    Returns:
    
    the instant after the last leap second.
    
    See Also:
    
    which uses similar code.
  - fromDatum
```
public static int[] fromDatum(Datum time)
```
    returns the 7-element array of components from the time location datum: 0:year, 1:month, 2:day, 3:hour, 4:minute, 5:second, 6:nanoseconds Note special care is taken to not use units conversions which introduce noise into the numbers, so the following units are handled directly: cdfTT2000, cdfEpoch, us2000, and mj1958. Also, a separate leap seconds table provides the leap seconds, since these are easily managed within code, removing the external dependence on a file.
    
    Parameters:
    
    time -
    
    Returns:
    
    seven-element int array.
    
    See Also:
    
    fromJulianDayAndOffset(int, int, int), which uses similar code and is not used because Java doesn't have tuple results.
  - toDatum
```
public static Datum toDatum(int[] timeArray)
```
    get the datum from the 6 or 7 element timeArray. The elements are: 0:year, 1:month, 2:day, 3:hour, 4:minute, 5:second, [ 6:nanoseconds ]
    
    Parameters:
    
    timeArray, - an int[6] or int[7].
    
    Returns:
    
    a datum representing the time.
  - toDatumDuration
```
public static Datum toDatumDuration(int[] timeArray)
```
    return approximate duration in Units.seconds or in Units.days. This is assuming a year is 365 days, a month is 30 days, and a day is 86400 seconds.
    
    Parameters:
    
    timeArray - 6 or 7 element array [ yrs, months, days, hours, minutes, seconds, nanos ]
    
    Returns:
    
    See Also:
    
    DatumRangeUtil.parseISO8601Duration(java.lang.String)
  - toDatum
```
public static Datum toDatum(int[] timeArray,
                            Units u)
```
    get the time datum from the 6 or 7 element decomposed timeArray. The elements are: 0:year, 1:month, 2:day, 3:hour, 4:minute, 5:second, [ 6:nanoseconds ]
    
    Parameters:
    
    timeArray, - an int[6] or int[7].
    
    u - target units.
    
    Returns:
    
    a datum representing the time.
  - isLeapYear
```
public static boolean isLeapYear(int year)
```
    return the leap year for years 1901-2099.
    
    Parameters:
    
    year -
    
    Returns:
  - carry
```
public static TimeUtil.TimeStruct carry(TimeUtil.TimeStruct t)
```
    Normalize the TimeStruct by incrementing higher digits. For example, 2002-01-01T24:00 → 2002-01-02T00:00. This will only carry one to the next higher place, so 70 seconds is handled but not 130. 2015-09-08: this now supports leap seconds.
    
    Parameters:
    
    t - a time structure
    
    Returns:
    
    a time structure where extra minutes are moved into hours, etc.
  - borrow
```
public static TimeUtil.TimeStruct borrow(TimeUtil.TimeStruct t)
```
    Normalize the TimeStruct by decrementing higher digits.
    
    Parameters:
    
    t - the time.
    
    Returns:
    
    the normalized TimeStruct
    
    Throws:
    
    java.lang.IllegalArgumentException - if t.day<0 or t.month<1
    
    See Also:
    
    normalize(org.das2.datum.TimeUtil.TimeStruct)
  - normalize
```
public static TimeUtil.TimeStruct normalize(TimeUtil.TimeStruct t)
```
    convert times like "2000-01-01T24:00" to "2000-01-02T00:00" and "2000-002T00:00" to "2000-01-02T00:00". This will only carry one to the next higher place, so 70 seconds is handled but not 130.
    
    Parameters:
    
    t -
    
    Returns:
    
    See Also:
    
    borrow(org.das2.datum.TimeUtil.TimeStruct)
  - roundNDigits
```
public static TimeUtil.TimeStruct roundNDigits(TimeUtil.TimeStruct ts,
                                               int n)
```
    round seconds to N decimal places. For example, n=3 means round to the millisecond.
    
    Parameters:
    
    ts - a time structure
    
    n - number of digits, 3 is millis, 6 is micros.
    
    Returns:
    
    rounded and normalized TimeStruct.
  - next
```
public static Datum next(TimeUtil.TimeDigit td,
                         int count,
                         Datum datum)
```
    return the next boundary
    
    Parameters:
    
    td - the boundary, e.g. TimeUtil.TD_HALF_YEAR
    
    count - the number of boundaries
    
    datum - the starting point.
    
    Returns:
    
    the boundary
  - next
```
public static Datum next(int step,
                         Datum datum)
```
    step to the next ordinal. If the datum is already at an ordinal boundary, then step to the next by one ordinal.
    
    Parameters:
    
    step - the ordinal location, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    datum - the location.
    
    Returns:
    
    the next boundary location.
  - ceil
```
public static Datum ceil(int step,
                         Datum datum)
```
    return the next ordinal boundary if we aren't at one already.
    
    Parameters:
    
    step - the ordinal location, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    datum - the location.
    
    Returns:
    
    the next ordinal boundary if we aren't at one already.
  - floor
```
public static Datum floor(int step,
                          Datum datum)
```
    return the previous ordinal boundary if we aren't at one already.
    
    Parameters:
    
    step - the ordinal location, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    datum - the location.
    
    Returns:
    
    the previous ordinal boundary if we aren't at one already.
  - nextMonth
```
public static Datum nextMonth(Datum datum)
```
    Deprecated. Use next(MONTH,datum) instead
    
    step to the next month.
    
    Parameters:
    
    datum -
    
    Returns:
    
    the next month.
  - prevWeek
```
public static Datum prevWeek(Datum datum)
```
    decrement by 7 days.
    
    Parameters:
    
    datum -
    
    Returns:
    
    the datum
  - dayContaining
```
public static DatumRange dayContaining(Datum t)
```
    return a DatumRange for the day containing the given time. Midnight is contained within the following day.
    
    Parameters:
    
    t - a time.
    
    Returns:
    
    the day containing the time.
  - rangeContaining
```
public static DatumRange rangeContaining(int count,
                                         int step,
                                         DatumRange tr)
```
    return the hours or minutes or days interval containing the time range, or multiple spans of this when the given range spans boundaries. For example, rangeContaining(1,TimeUtil.DAY,datumRange('2024-07-17T23:30/2024-07-18T00:30')) would be '2024-07-17/2024-07-19'.
    
    Parameters:
    
    count, - which must be 1 or a factor of 60.
    
    step - the ordinal unit, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    tr - the timerange
    
    Returns:
    
    the range containing the interval.
  - rangeContaining
```
public static DatumRange rangeContaining(int count,
                                         int step,
                                         Datum t)
```
    return the hour or minute or day
    
    Parameters:
    
    count, - which must be 1 or a factor of 60.
    
    step - the ordinal unit, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    t - the time
    
    Returns:
    
    the range containing the interval.
  - prev
```
public static Datum prev(int step,
                         Datum datum)
```
    step down the previous ordinal. If the datum is already at an ordinal boundary, then step down by one ordinal.
    
    Parameters:
    
    step - the ordinal location, such as TimeUtil.DAY or TimeUtil.HALF_YEAR
    
    datum - the location.
    
    Returns:
    
    the prev boundary location.
  - now
```
public static Datum now()
```
    return the current time as a Datum.
    
    Returns:
    
    the current time as a Datum.
  - convert
```
public static double convert(int year,
                             int month,
                             int day,
                             int hour,
                             int minute,
                             double second,
                             TimeLocationUnits units)
```
    convert the month components to a double in the given units.
    
    Parameters:
    
    year - the year, which must be greater than 1582
    
    month - the month
    
    day - the day of month, unless month==0, then day is day of year.
    
    hour - additional hours
    
    minute - additional minutes
    
    second - additional seconds
    
    units - the Units in which to return the result.
    
    Returns:
    
    a double in the given units.
  - monthNumber
```
public static int monthNumber(java.lang.String s)
                       throws java.text.ParseException
```
    returns 1..12 for the English month name. (Sorry, rest of world...)
    
    Parameters:
    
    s - the three-letter month name, jan,feb,...,nov,dec
    
    Returns:
    
    1,2,...,11,12 for the English month name
    
    Throws:
    
    java.text.ParseException - if the name isn't recognized
  - monthNameAbbrev
```
public static java.lang.String monthNameAbbrev(int mon)
```
    returns "Jan", "Feb", ... for month number (1..12).
    
    Parameters:
    
    mon - integer from 1 to 12.
    
    Returns:
    
    three character English month name.
  - parseTime
```
public static TimeUtil.TimeStruct parseTime(java.lang.String s)
                                     throws java.text.ParseException
```
    parse the time into a timestruct.
    
    Parameters:
    
    s -
    
    Returns:
    
    Throws:
    
    java.text.ParseException
    
    See Also:
    
    createValid which creates a Datum.
  - create
```
public static Datum create(java.lang.String s)
                    throws java.text.ParseException
```
    Creates a datum from a string
    
    Parameters:
    
    s -
    
    Returns:
    
    Throws:
    
    java.text.ParseException
  - createValid
```
public static Datum createValid(java.lang.String validString)
```
    creates a Datum from a string which is known to contain a valid time format. Throws a RuntimeException if the string is not valid.
    
    Parameters:
    
    validString -
    
    Returns:
  - isValidTime
```
public static boolean isValidTime(java.lang.String string)
```
    check to see if the string is parseable as a time.
    
    Parameters:
    
    string - any string
    
    Returns:
    
    true if the string is clearly a time.
    
    See Also:
    
    create(java.lang.String)
  - main
```
public static void main(java.lang.String[] args)
                 throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - prevMidnight
```
public static Datum prevMidnight(Datum datum)
```
    provide the previous midnight, similar to the floor function, noting that if the datum provided is midnight exactly then it is simply returned.
    
    Parameters:
    
    datum -
    
    Returns:
    
    the Datum for the next day boundary.
  - nextMidnight
```
public static Datum nextMidnight(Datum datum)
```
    provide the next midnight, similar to the ceil function, noting that if the datum provided is midnight already then it is simply returned.
    
    Parameters:
    
    datum -
    
    Returns:
    
    the Datum for the next day boundary.
  - createTimeDatum
```
public static Datum createTimeDatum(int year,
                                    int month,
                                    int day,
                                    int hour,
                                    int minute,
                                    int second,
                                    int nano)
```
    creates a Datum representing the time given in integer years, months, ..., seconds, nanoseconds. The year must be at least 1000, and must be a four-digit year. A double in Units.us2000 is used to represent the Datum, so resolution will drop as the year drops away from 2000.
    
    Parameters:
    
    year - four digit year >= 1060.
    
    month - integer month, 1..12.
    
    day - integer day of month.
    
    hour - additional hours
    
    minute - additional minutes
    
    second - additional seconds
    
    nano - additional nanoseconds
    
    Returns:
    
    a Datum with units Units.us2000.

Class TimeUtil

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

YEAR

MONTH

DAY

HOUR

MINUTE

SECOND

MILLI

MICRO

NANO

WEEK

QUARTER

HALF_YEAR

TD_YEAR

TD_MONTH

TD_DAY

TD_HOUR

TD_MINUTE

TD_SECOND

TD_MILLI

TD_MICRO

TD_NANO

Method Detail

daysInMonth

julianDayIMCCE

julianDay

dayOfYear

getSecondsSinceMidnight

getMicroSecondsSinceMidnight

getJulianDay

getJulianDay

toDatum

toDatum

julianToGregorian

toTimeStruct

toTimeStruct

add

subtract

toTimeArray

lastLeapSecond

fromDatum

toDatum

toDatumDuration

toDatum

isLeapYear

carry

borrow

normalize

roundNDigits

next

next

ceil

floor

nextMonth

prevWeek

dayContaining

rangeContaining

rangeContaining

prev

now

convert

monthNumber

monthNameAbbrev

parseTime

create

createValid

isValidTime

main

prevMidnight

nextMidnight

createTimeDatum