java.lang.Object
- com.helger.commons.datetime.PDTFactory

```
@Immutable
public final class PDTFactory
extends Object
```
Philip's Date Time (PDT) factory. Create and convert different date and time stuff into each other. Everything that creates a ZonedDateTime, OffsetDateTime, OffsetDate or OffsetTime uses the default time zone from PDTConfig if necessary. The addition "UTC" to the name of the method indicates the explicit usage of the UTC time zone.

Author:

Philip Helger

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static Calendar`	`createCalendar()`
`static Calendar`	`createCalendarUTC()`
`static Date`	`createDate(OffsetDate aOD)`
`static Date`	`createDate(XMLOffsetDate aOD)`
`static Date`	`createDate(XMLOffsetTime a)`
`static Date`	`createDate(LocalDate a)`
`static Date`	`createDate(LocalDateTime a)`
`static Date`	`createDate(LocalTime a)`
`static Date`	`createDate(OffsetDateTime a)`
`static Date`	`createDate(OffsetTime a)`
`static Date`	`createDate(ZonedDateTime a)`
`static Date`	`createDateForDate(int nYear, Month eMonth, int nDayOfMonth)`
`static Date`	`createDateForTime(int nHour, int nMin, int nSec)`
`static GregorianCalendar`	`createGregorianCalendar()`
`static GregorianCalendar`	`createGregorianCalendarUTC()`
`static LocalDate`	`createLocalDate(int nYear, Month eMonth, int nDayOfMonth)`
`static LocalDate`	`createLocalDate(long nMillis)`
`static LocalDate`	`createLocalDate(XMLOffsetDate a)`
`static LocalDate`	`createLocalDate(XMLOffsetDateTime a)`
`static LocalDate`	`createLocalDate(Number a)`
`static LocalDate`	`createLocalDate(Instant a)`
`static LocalDate`	`createLocalDate(LocalDateTime a)`
`static LocalDate`	`createLocalDate(OffsetDateTime a)`
`static LocalDate`	`createLocalDate(Year a)`
`static LocalDate`	`createLocalDate(YearMonth a)`
`static LocalDate`	`createLocalDate(ZonedDateTime a)`
`static LocalDate`	`createLocalDate(Date a)`
`static LocalDate`	`createLocalDate(GregorianCalendar a)`
`static LocalDateTime`	`createLocalDateTime(int nYear, Month eMonth, int nDay)`
`static LocalDateTime`	`createLocalDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute)`
`static LocalDateTime`	`createLocalDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static LocalDateTime`	`createLocalDateTime(long nMillis)`
`static LocalDateTime`	`createLocalDateTime(OffsetDate aDT)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetDate aDT)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetDateTime aDT)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetTime a)`
`static LocalDateTime`	`createLocalDateTime(Number a)`
`static LocalDateTime`	`createLocalDateTime(Timestamp a)`
`static LocalDateTime`	`createLocalDateTime(Instant a)`
`static LocalDateTime`	`createLocalDateTime(LocalDate a)`
`static LocalDateTime`	`createLocalDateTime(LocalTime a)`
`static LocalDateTime`	`createLocalDateTime(OffsetDateTime aDT)`
`static LocalDateTime`	`createLocalDateTime(OffsetTime a)`
`static LocalDateTime`	`createLocalDateTime(Year a)`
`static LocalDateTime`	`createLocalDateTime(YearMonth a)`
`static LocalDateTime`	`createLocalDateTime(ZonedDateTime aDT)`
`static LocalDateTime`	`createLocalDateTime(Date a)`
`static LocalDateTime`	`createLocalDateTime(GregorianCalendar aCal)`
`static LocalTime`	`createLocalTime(int nHour, int nMinute, int nSecond)`
`static LocalTime`	`createLocalTime(long nMillis)`
`static LocalTime`	`createLocalTime(XMLOffsetTime a)`
`static LocalTime`	`createLocalTime(Instant a)`
`static LocalTime`	`createLocalTime(LocalDateTime a)`
`static LocalTime`	`createLocalTime(OffsetTime a)`
`static LocalTime`	`createLocalTime(Date a)`
`static LocalTime`	`createLocalTime(GregorianCalendar a)`
`static OffsetDate`	`createOffsetDate(int nYear, Month eMonth, int nDayOfMonth)`
`static OffsetDate`	`createOffsetDate(int nYear, Month eMonth, int nDayOfMonth, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(long nMillis)`
`static OffsetDate`	`createOffsetDate(Number a)`
`static OffsetDate`	`createOffsetDate(Instant a)`
`static OffsetDate`	`createOffsetDate(Instant a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(LocalDate a)`
`static OffsetDate`	`createOffsetDate(LocalDate a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(LocalDateTime a)`
`static OffsetDate`	`createOffsetDate(LocalDateTime a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(OffsetDateTime a)`
`static OffsetDate`	`createOffsetDate(Year a)`
`static OffsetDate`	`createOffsetDate(YearMonth a)`
`static OffsetDate`	`createOffsetDate(ZonedDateTime a)`
`static OffsetDate`	`createOffsetDate(Date a)`
`static OffsetDate`	`createOffsetDate(GregorianCalendar a)`
`static OffsetDateTime`	`createOffsetDateTime(int nYear, Month eMonth, int nDay)`
`static OffsetDateTime`	`createOffsetDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static OffsetDateTime`	`createOffsetDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond, ZoneOffset aZoneOffset)`
`static OffsetDateTime`	`createOffsetDateTime(long nMillis)`
`static OffsetDateTime`	`createOffsetDateTime(OffsetDate aOD)`
`static OffsetDateTime`	`createOffsetDateTime(XMLOffsetDate aOD)`
`static OffsetDateTime`	`createOffsetDateTime(XMLOffsetTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Number a)`
`static OffsetDateTime`	`createOffsetDateTime(Timestamp a)`
`static OffsetDateTime`	`createOffsetDateTime(Instant a)`
`static OffsetDateTime`	`createOffsetDateTime(LocalDate a)`
`static OffsetDateTime`	`createOffsetDateTime(LocalDateTime a)`
`static OffsetDateTime`	`createOffsetDateTime(LocalTime a)`
`static OffsetDateTime`	`createOffsetDateTime(OffsetTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Year a)`
`static OffsetDateTime`	`createOffsetDateTime(YearMonth a)`
`static OffsetDateTime`	`createOffsetDateTime(ZonedDateTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Date a)`
`static OffsetDateTime`	`createOffsetDateTime(GregorianCalendar aCal)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(int nYear, Month eMonth, int nDay)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(long nMillis)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Number a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Instant a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(LocalDate a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(LocalDateTime a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(LocalTime a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Year a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(YearMonth a)`
`static OffsetTime`	`createOffsetTime(int nHour, int nMinute, int nSecond, ZoneOffset aOfs)`
`static OffsetTime`	`createOffsetTime(long nMillis)`
`static OffsetTime`	`createOffsetTime(Instant a)`
`static OffsetTime`	`createOffsetTime(LocalDateTime a)`
`static OffsetTime`	`createOffsetTime(LocalDateTime a, ZoneOffset aOfs)`
`static OffsetTime`	`createOffsetTime(LocalTime a)`
`static OffsetTime`	`createOffsetTime(LocalTime a, ZoneOffset aOfs)`
`static OffsetTime`	`createOffsetTime(OffsetDateTime a)`
`static OffsetTime`	`createOffsetTime(ZonedDateTime a)`
`static OffsetTime`	`createOffsetTime(Date a)`
`static OffsetTime`	`createOffsetTime(GregorianCalendar a)`
`static XMLOffsetDate`	`createXMLOffsetDate(int nYear, Month eMonth, int nDayOfMonth)`
`static XMLOffsetDate`	`createXMLOffsetDate(int nYear, Month eMonth, int nDayOfMonth, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(long nMillis)`
`static XMLOffsetDate`	`createXMLOffsetDate(XMLOffsetDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Number a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Instant a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Instant a, ZoneId aZoneId)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDate a)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDate a, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDateTime a, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(OffsetDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Year a)`
`static XMLOffsetDate`	`createXMLOffsetDate(YearMonth a)`
`static XMLOffsetDate`	`createXMLOffsetDate(ZonedDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Date a)`
`static XMLOffsetDate`	`createXMLOffsetDate(GregorianCalendar a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(int nYear, Month eMonth, int nDay)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond, ZoneOffset aZoneOffset)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(long nMillis)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetDate aOD)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(XMLOffsetDate aOD)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(XMLOffsetTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Number a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Timestamp a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Instant a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(LocalDate a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(LocalDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(LocalTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Year a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(YearMonth a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(ZonedDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Date a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(GregorianCalendar aCal)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(int nYear, Month eMonth, int nDay)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(long nMillis)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Number a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Instant a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(LocalDate a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(LocalDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(LocalTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Year a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(YearMonth a)`
`static XMLOffsetTime`	`createXMLOffsetTime(int nHour, int nMinute, int nSecond)`
`static XMLOffsetTime`	`createXMLOffsetTime(int nHour, int nMinute, int nSecond, ZoneOffset aOfs)`
`static XMLOffsetTime`	`createXMLOffsetTime(long nMillis)`
`static XMLOffsetTime`	`createXMLOffsetTime(Instant a)`
`static XMLOffsetTime`	`createXMLOffsetTime(LocalDateTime a)`
`static XMLOffsetTime`	`createXMLOffsetTime(LocalDateTime a, ZoneOffset aOfs)`
`static XMLOffsetTime`	`createXMLOffsetTime(LocalTime a)`
`static XMLOffsetTime`	`createXMLOffsetTime(LocalTime a, ZoneOffset aOfs)`
`static XMLOffsetTime`	`createXMLOffsetTime(OffsetDateTime a)`
`static XMLOffsetTime`	`createXMLOffsetTime(ZonedDateTime a)`
`static XMLOffsetTime`	`createXMLOffsetTime(Date a)`
`static XMLOffsetTime`	`createXMLOffsetTime(GregorianCalendar a)`
`static ZonedDateTime`	`createZonedDateTime(int nYear, Month eMonth, int nDay)`
`static ZonedDateTime`	`createZonedDateTime(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static ZonedDateTime`	`createZonedDateTime(long nMillis)`
`static ZonedDateTime`	`createZonedDateTime(OffsetDate aOD)`
`static ZonedDateTime`	`createZonedDateTime(XMLOffsetDate aOD)`
`static ZonedDateTime`	`createZonedDateTime(XMLOffsetTime a)`
`static ZonedDateTime`	`createZonedDateTime(Number a)`
`static ZonedDateTime`	`createZonedDateTime(Timestamp a)`
`static ZonedDateTime`	`createZonedDateTime(Instant a)`
`static ZonedDateTime`	`createZonedDateTime(LocalDate a)`
`static ZonedDateTime`	`createZonedDateTime(LocalDateTime a)`
`static ZonedDateTime`	`createZonedDateTime(LocalTime a)`
`static ZonedDateTime`	`createZonedDateTime(OffsetDateTime a)`
`static ZonedDateTime`	`createZonedDateTime(OffsetTime a)`
`static ZonedDateTime`	`createZonedDateTime(Year a)`
`static ZonedDateTime`	`createZonedDateTime(YearMonth a)`
`static ZonedDateTime`	`createZonedDateTime(Date a)`
`static ZonedDateTime`	`createZonedDateTime(GregorianCalendar aCal)`
`static ZonedDateTime`	`createZonedDateTimeUTC(int nYear, Month eMonth, int nDay)`
`static ZonedDateTime`	`createZonedDateTimeUTC(int nYear, Month eMonth, int nDay, int nHour, int nMinute, int nSecond)`
`static ZonedDateTime`	`createZonedDateTimeUTC(long nMillis)`
`static ZonedDateTime`	`createZonedDateTimeUTC(Number a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(Instant a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(LocalDate a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(LocalDateTime a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(LocalTime a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(Year a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(YearMonth a)`
`static Instant`	`getCurrentInstant()`
`static Instant`	`getCurrentInstantUTC()`
`static LocalDate`	`getCurrentLocalDate()`
`static LocalDateTime`	`getCurrentLocalDateTime()`
`static LocalDateTime`	`getCurrentLocalDateTimeMillisOnly()`
`static LocalDateTime`	`getCurrentLocalDateTimeMillisOnlyUTC()`
`static LocalDateTime`	`getCurrentLocalDateTimeUTC()`
`static LocalDate`	`getCurrentLocalDateUTC()`
`static LocalTime`	`getCurrentLocalTime()`
`static LocalTime`	`getCurrentLocalTimeMillisOnly()`
`static LocalTime`	`getCurrentLocalTimeMillisOnlyUTC()`
`static LocalTime`	`getCurrentLocalTimeUTC()`
`static long`	`getCurrentMillis()`
`static long`	`getCurrentMillisUTC()`
`static MonthDay`	`getCurrentMonthDay()`
`static MonthDay`	`getCurrentMonthDayUTC()`
`static OffsetDate`	`getCurrentOffsetDate()`
`static OffsetDateTime`	`getCurrentOffsetDateTime()`
`static OffsetDateTime`	`getCurrentOffsetDateTimeMillisOnly()`
`static OffsetDateTime`	`getCurrentOffsetDateTimeMillisOnlyUTC()`
`static OffsetDateTime`	`getCurrentOffsetDateTimeUTC()`
`static OffsetDate`	`getCurrentOffsetDateUTC()`
`static OffsetTime`	`getCurrentOffsetTime()`
`static OffsetTime`	`getCurrentOffsetTimeMillisOnly()`
`static OffsetTime`	`getCurrentOffsetTimeMillisOnlyUTC()`
`static OffsetTime`	`getCurrentOffsetTimeUTC()`
`static XMLOffsetDate`	`getCurrentXMLOffsetDate()`
`static XMLOffsetDateTime`	`getCurrentXMLOffsetDateTime()`
`static XMLOffsetDateTime`	`getCurrentXMLOffsetDateTimeMillisOnly()`
`static XMLOffsetDateTime`	`getCurrentXMLOffsetDateTimeMillisOnlyUTC()`
`static XMLOffsetDateTime`	`getCurrentXMLOffsetDateTimeUTC()`
`static XMLOffsetDate`	`getCurrentXMLOffsetDateUTC()`
`static XMLOffsetTime`	`getCurrentXMLOffsetTime()`
`static XMLOffsetTime`	`getCurrentXMLOffsetTimeMillisOnly()`
`static XMLOffsetTime`	`getCurrentXMLOffsetTimeMillisOnlyUTC()`
`static XMLOffsetTime`	`getCurrentXMLOffsetTimeUTC()`
`static int`	`getCurrentYear()`
`static YearMonth`	`getCurrentYearMonth()`
`static YearMonth`	`getCurrentYearMonthUTC()`
`static Year`	`getCurrentYearObj()`
`static Year`	`getCurrentYearObjUTC()`
`static int`	`getCurrentYearUTC()`
`static ZonedDateTime`	`getCurrentZonedDateTime()`
`static ZonedDateTime`	`getCurrentZonedDateTimeMillisOnly()`
`static ZonedDateTime`	`getCurrentZonedDateTimeMillisOnlyUTC()`
`static ZonedDateTime`	`getCurrentZonedDateTimeUTC()`
`static long`	`getMillis(OffsetDate aOD)`
`static long`	`getMillis(XMLOffsetDate aOD)`
`static long`	`getMillis(XMLOffsetDateTime a)`
`static long`	`getMillis(XMLOffsetTime a)`
`static long`	`getMillis(LocalDate a)`
`static long`	`getMillis(LocalDateTime a)`
`static long`	`getMillis(LocalTime a)`
`static long`	`getMillis(OffsetDateTime a)`
`static long`	`getMillis(OffsetTime a)`
`static long`	`getMillis(ZonedDateTime a)`
`static TimeZone`	`getTimeZone(Date a)`
`static int`	`getTimezoneOffsetInMinutes(ZoneId aZID, Instant aAt)`
`static int`	`getTimezoneOffsetInMinutes(ZoneOffset aZO)`
`static int`	`getTimezoneOffsetInMinutes(Date a)`	Get the time zone offset to UTC of the passed Date in minutes to be used in `XMLGregorianCalendar`.
`static int`	`getTimezoneOffsetInMinutes(GregorianCalendar aCal)`
`static XMLOffsetDateTime`	`getWithMillisOnly(XMLOffsetDateTime a)`	Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static XMLOffsetTime`	`getWithMillisOnly(XMLOffsetTime a)`	Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static LocalDateTime`	`getWithMillisOnly(LocalDateTime a)`	Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static LocalTime`	`getWithMillisOnly(LocalTime a)`	Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static OffsetDateTime`	`getWithMillisOnly(OffsetDateTime a)`	Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static OffsetTime`	`getWithMillisOnly(OffsetTime a)`	Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static ZonedDateTime`	`getWithMillisOnly(ZonedDateTime a)`	Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present.
`static ZoneId`	`getZoneId(Date a)`
`static ZoneId`	`getZoneIdFromOffsetInMinutes(int nOffsetInMinutes)`
`static ZoneOffset`	`getZoneOffset(Date a)`
`static ZoneOffset`	`getZoneOffsetFromOffsetInMinutes(int nOffsetInMinutes)`

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

Method Detail

getTimezoneOffsetInMinutes
```
public static int getTimezoneOffsetInMinutes(@Nonnull
                                             Date a)
```
Get the time zone offset to UTC of the passed Date in minutes to be used in XMLGregorianCalendar.

Parameters:

a - The date to use. May not be null.

Returns:

0 for no offset to UTC, the minutes otherwise. Usually in 60minutes steps :)

getTimezoneOffsetInMinutes

public static int getTimezoneOffsetInMinutes(@Nonnull
                                             GregorianCalendar aCal)

getTimezoneOffsetInMinutes

public static int getTimezoneOffsetInMinutes(@Nonnull
                                             ZoneId aZID,
                                             @Nonnull
                                             Instant aAt)

getTimezoneOffsetInMinutes

public static int getTimezoneOffsetInMinutes(@Nonnull
                                             ZoneOffset aZO)

getZoneOffsetFromOffsetInMinutes

@Nonnull
public static ZoneOffset getZoneOffsetFromOffsetInMinutes(int nOffsetInMinutes)

getZoneOffset

@Nonnull
public static ZoneOffset getZoneOffset(@Nonnull
                                       Date a)

getZoneIdFromOffsetInMinutes

@Nonnull
public static ZoneId getZoneIdFromOffsetInMinutes(int nOffsetInMinutes)

getZoneId

@Nonnull
public static ZoneId getZoneId(@Nonnull
                               Date a)

getTimeZone

@Nonnull
public static TimeZone getTimeZone(@Nonnull
                                   Date a)

getCurrentZonedDateTime

@Nonnull
public static ZonedDateTime getCurrentZonedDateTime()

getCurrentZonedDateTimeUTC

@Nonnull
public static ZonedDateTime getCurrentZonedDateTimeUTC()

getWithMillisOnly
```
@Nullable
public static ZonedDateTime getWithMillisOnly(@Nullable
                                              ZonedDateTime a)
```
Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source date time. May be null.

Returns:

null if the parameter is null, the local date time with microseconds and nanoseconds set to 0 otherwise.

Since:

9.2.0

getCurrentZonedDateTimeMillisOnly
```
@Nonnegative
public static ZonedDateTime getCurrentZonedDateTimeMillisOnly()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Since:

9.2.0

getCurrentZonedDateTimeMillisOnlyUTC
```
@Nonnegative
public static ZonedDateTime getCurrentZonedDateTimeMillisOnlyUTC()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                OffsetDateTime a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                LocalDateTime a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   LocalDateTime a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                LocalDate a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   LocalDate a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                OffsetDate aOD)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                XMLOffsetDate aOD)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                YearMonth a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   YearMonth a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                Year a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   Year a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                LocalTime a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   LocalTime a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                OffsetTime a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                XMLOffsetTime a)

createZonedDateTime

@Nonnull
public static ZonedDateTime createZonedDateTime(int nYear,
                                                Month eMonth,
                                                int nDay)

createZonedDateTimeUTC

@Nonnull
public static ZonedDateTime createZonedDateTimeUTC(int nYear,
                                                   Month eMonth,
                                                   int nDay)

createZonedDateTime

@Nonnull
public static ZonedDateTime createZonedDateTime(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDay,
                                                int nHour,
                                                int nMinute,
                                                int nSecond)

createZonedDateTimeUTC

@Nonnull
public static ZonedDateTime createZonedDateTimeUTC(int nYear,
                                                   @Nonnull
                                                   Month eMonth,
                                                   int nDay,
                                                   int nHour,
                                                   int nMinute,
                                                   int nSecond)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                Instant a)

createZonedDateTimeUTC

@Nullable
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   Instant a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                GregorianCalendar aCal)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                Date a)

createZonedDateTime

@Nullable
public static ZonedDateTime createZonedDateTime(@Nullable
                                                Timestamp a)

createZonedDateTime

@Nonnull
public static ZonedDateTime createZonedDateTime(long nMillis)

createZonedDateTimeUTC

@Nonnull
public static ZonedDateTime createZonedDateTimeUTC(long nMillis)

createZonedDateTime

@Nonnull
public static ZonedDateTime createZonedDateTime(@Nullable
                                                Number a)

createZonedDateTimeUTC

@Nonnull
public static ZonedDateTime createZonedDateTimeUTC(@Nullable
                                                   Number a)

getCurrentOffsetDateTime

@Nonnegative
public static OffsetDateTime getCurrentOffsetDateTime()

getCurrentOffsetDateTimeUTC

@Nonnegative
public static OffsetDateTime getCurrentOffsetDateTimeUTC()

getWithMillisOnly
```
@Nullable
public static OffsetDateTime getWithMillisOnly(@Nullable
                                               OffsetDateTime a)
```
Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source date time. May be null.

Returns:

null if the parameter is null, the local date time with microseconds and nanoseconds set to 0 otherwise.

Since:

9.2.0

getCurrentOffsetDateTimeMillisOnly
```
@Nonnegative
public static OffsetDateTime getCurrentOffsetDateTimeMillisOnly()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Since:

9.2.0

getCurrentOffsetDateTimeMillisOnlyUTC
```
@Nonnegative
public static OffsetDateTime getCurrentOffsetDateTimeMillisOnlyUTC()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  ZonedDateTime a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  LocalDateTime a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     LocalDateTime a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  LocalDate a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     LocalDate a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  OffsetDate aOD)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  XMLOffsetDate aOD)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  YearMonth a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     YearMonth a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  Year a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     Year a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  LocalTime a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     LocalTime a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  OffsetTime a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  XMLOffsetTime a)

createOffsetDateTime

@Nonnull
public static OffsetDateTime createOffsetDateTime(int nYear,
                                                  Month eMonth,
                                                  int nDay)

createOffsetDateTimeUTC

@Nonnull
public static OffsetDateTime createOffsetDateTimeUTC(int nYear,
                                                     Month eMonth,
                                                     int nDay)

createOffsetDateTime

@Nonnull
public static OffsetDateTime createOffsetDateTime(int nYear,
                                                  @Nonnull
                                                  Month eMonth,
                                                  int nDay,
                                                  int nHour,
                                                  int nMinute,
                                                  int nSecond)

createOffsetDateTime

@Nonnull
public static OffsetDateTime createOffsetDateTime(int nYear,
                                                  @Nonnull
                                                  Month eMonth,
                                                  int nDay,
                                                  int nHour,
                                                  int nMinute,
                                                  int nSecond,
                                                  @Nonnull
                                                  ZoneOffset aZoneOffset)

createOffsetDateTimeUTC

@Nonnull
public static OffsetDateTime createOffsetDateTimeUTC(int nYear,
                                                     @Nonnull
                                                     Month eMonth,
                                                     int nDay,
                                                     int nHour,
                                                     int nMinute,
                                                     int nSecond)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  Instant a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     Instant a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  Date a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  Timestamp a)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  GregorianCalendar aCal)

createOffsetDateTime

@Nonnull
public static OffsetDateTime createOffsetDateTime(long nMillis)

createOffsetDateTimeUTC

@Nonnull
public static OffsetDateTime createOffsetDateTimeUTC(long nMillis)

createOffsetDateTime

@Nullable
public static OffsetDateTime createOffsetDateTime(@Nullable
                                                  Number a)

createOffsetDateTimeUTC

@Nullable
public static OffsetDateTime createOffsetDateTimeUTC(@Nullable
                                                     Number a)

getCurrentXMLOffsetDateTime

@Nonnegative
public static XMLOffsetDateTime getCurrentXMLOffsetDateTime()

getCurrentXMLOffsetDateTimeUTC

@Nonnegative
public static XMLOffsetDateTime getCurrentXMLOffsetDateTimeUTC()

getWithMillisOnly
```
@Nullable
public static XMLOffsetDateTime getWithMillisOnly(@Nullable
                                                  XMLOffsetDateTime a)
```
Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source date time. May be null.

Returns:

null if the parameter is null, the local date time with microseconds and nanoseconds set to 0 otherwise.

getCurrentXMLOffsetDateTimeMillisOnly
```
@Nonnegative
public static XMLOffsetDateTime getCurrentXMLOffsetDateTimeMillisOnly()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

getCurrentXMLOffsetDateTimeMillisOnlyUTC
```
@Nonnegative
public static XMLOffsetDateTime getCurrentXMLOffsetDateTimeMillisOnlyUTC()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        ZonedDateTime a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        OffsetDateTime a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        LocalDateTime a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           LocalDateTime a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        LocalDate a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           LocalDate a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        OffsetDate aOD)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        XMLOffsetDate aOD)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        YearMonth a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           YearMonth a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        Year a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           Year a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        LocalTime a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           LocalTime a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        OffsetTime a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        XMLOffsetTime a)

createXMLOffsetDateTime

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTime(int nYear,
                                                        Month eMonth,
                                                        int nDay)

createXMLOffsetDateTimeUTC

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(int nYear,
                                                           Month eMonth,
                                                           int nDay)

createXMLOffsetDateTime

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTime(int nYear,
                                                        @Nonnull
                                                        Month eMonth,
                                                        int nDay,
                                                        int nHour,
                                                        int nMinute,
                                                        int nSecond)

createXMLOffsetDateTime

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTime(int nYear,
                                                        @Nonnull
                                                        Month eMonth,
                                                        int nDay,
                                                        int nHour,
                                                        int nMinute,
                                                        int nSecond,
                                                        @Nullable
                                                        ZoneOffset aZoneOffset)

createXMLOffsetDateTimeUTC

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(int nYear,
                                                           @Nonnull
                                                           Month eMonth,
                                                           int nDay,
                                                           int nHour,
                                                           int nMinute,
                                                           int nSecond)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        Instant a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           Instant a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        Date a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        Timestamp a)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        GregorianCalendar aCal)

createXMLOffsetDateTime

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTime(long nMillis)

createXMLOffsetDateTimeUTC

@Nonnull
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(long nMillis)

createXMLOffsetDateTime

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTime(@Nullable
                                                        Number a)

createXMLOffsetDateTimeUTC

@Nullable
public static XMLOffsetDateTime createXMLOffsetDateTimeUTC(@Nullable
                                                           Number a)

getCurrentLocalDateTime

@Nonnegative
public static LocalDateTime getCurrentLocalDateTime()

getCurrentLocalDateTimeUTC

@Nonnegative
public static LocalDateTime getCurrentLocalDateTimeUTC()

getWithMillisOnly
```
@Nullable
public static LocalDateTime getWithMillisOnly(@Nullable
                                              LocalDateTime a)
```
Get the passed date time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source date time. May be null.

Returns:

null if the parameter is null, the local date time with microseconds and nanoseconds set to 0 otherwise.

Since:

9.2.0

getCurrentLocalDateTimeMillisOnly
```
@Nonnegative
public static LocalDateTime getCurrentLocalDateTimeMillisOnly()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Since:

9.2.0

getCurrentLocalDateTimeMillisOnlyUTC
```
@Nonnegative
public static LocalDateTime getCurrentLocalDateTimeMillisOnlyUTC()
```
Returns:

The current local date and time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                ZonedDateTime aDT)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                OffsetDateTime aDT)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                XMLOffsetDateTime aDT)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                OffsetDate aDT)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                XMLOffsetDate aDT)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                LocalDate a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                YearMonth a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                Year a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                LocalTime a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                OffsetTime a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                XMLOffsetTime a)

createLocalDateTime

@Nonnull
public static LocalDateTime createLocalDateTime(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDay)

createLocalDateTime

@Nonnull
public static LocalDateTime createLocalDateTime(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDay,
                                                int nHour,
                                                int nMinute)

createLocalDateTime

@Nonnull
public static LocalDateTime createLocalDateTime(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDay,
                                                int nHour,
                                                int nMinute,
                                                int nSecond)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                Instant a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                Date a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                Timestamp a)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                GregorianCalendar aCal)

createLocalDateTime

@Nonnull
public static LocalDateTime createLocalDateTime(long nMillis)

createLocalDateTime

@Nullable
public static LocalDateTime createLocalDateTime(@Nullable
                                                Number a)

getCurrentLocalDate

@Nonnegative
public static LocalDate getCurrentLocalDate()

getCurrentLocalDateUTC

@Nonnegative
public static LocalDate getCurrentLocalDateUTC()

createLocalDate

@Nonnull
public static LocalDate createLocalDate(int nYear,
                                        @Nonnull
                                        Month eMonth,
                                        int nDayOfMonth)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        GregorianCalendar a)

createLocalDate

@Nonnull
public static LocalDate createLocalDate(long nMillis)

createLocalDate

@Nonnull
public static LocalDate createLocalDate(@Nullable
                                        Number a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        Instant a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        Date a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        YearMonth a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        Year a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        LocalDateTime a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        ZonedDateTime a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        OffsetDateTime a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        XMLOffsetDateTime a)

createLocalDate

@Nullable
public static LocalDate createLocalDate(@Nullable
                                        XMLOffsetDate a)

getCurrentOffsetDate

@Nonnegative
public static OffsetDate getCurrentOffsetDate()

getCurrentOffsetDateUTC

@Nonnegative
public static OffsetDate getCurrentOffsetDateUTC()

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          LocalDate a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          LocalDate a,
                                          @Nonnull
                                          ZoneOffset aOffset)

createOffsetDate

@Nonnull
public static OffsetDate createOffsetDate(int nYear,
                                          @Nonnull
                                          Month eMonth,
                                          int nDayOfMonth)

createOffsetDate

@Nonnull
public static OffsetDate createOffsetDate(int nYear,
                                          @Nonnull
                                          Month eMonth,
                                          int nDayOfMonth,
                                          @Nonnull
                                          ZoneOffset aOffset)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          LocalDateTime a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          LocalDateTime a,
                                          @Nonnull
                                          ZoneOffset aOffset)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          GregorianCalendar a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          Instant a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          Instant a,
                                          @Nonnull
                                          ZoneOffset aOffset)

createOffsetDate

@Nonnull
public static OffsetDate createOffsetDate(long nMillis)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          Number a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          Date a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          YearMonth a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          Year a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          OffsetDateTime a)

createOffsetDate

@Nullable
public static OffsetDate createOffsetDate(@Nullable
                                          ZonedDateTime a)

getCurrentXMLOffsetDate

@Nonnegative
public static XMLOffsetDate getCurrentXMLOffsetDate()

getCurrentXMLOffsetDateUTC

@Nonnegative
public static XMLOffsetDate getCurrentXMLOffsetDateUTC()

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                ZonedDateTime a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                OffsetDateTime a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                XMLOffsetDateTime a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                LocalDate a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                LocalDate a,
                                                @Nonnull
                                                ZoneOffset aOffset)

createXMLOffsetDate

@Nonnull
public static XMLOffsetDate createXMLOffsetDate(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDayOfMonth)

createXMLOffsetDate

@Nonnull
public static XMLOffsetDate createXMLOffsetDate(int nYear,
                                                @Nonnull
                                                Month eMonth,
                                                int nDayOfMonth,
                                                @Nullable
                                                ZoneOffset aOffset)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                LocalDateTime a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                LocalDateTime a,
                                                @Nonnull
                                                ZoneOffset aOffset)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                Instant a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                Instant a,
                                                @Nonnull
                                                ZoneId aZoneId)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                GregorianCalendar a)

createXMLOffsetDate

@Nonnull
public static XMLOffsetDate createXMLOffsetDate(long nMillis)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                Date a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                YearMonth a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                Year a)

createXMLOffsetDate

@Nullable
public static XMLOffsetDate createXMLOffsetDate(@Nullable
                                                Number a)

getCurrentLocalTime

@Nonnegative
public static LocalTime getCurrentLocalTime()

getCurrentLocalTimeUTC

@Nonnegative
public static LocalTime getCurrentLocalTimeUTC()

getWithMillisOnly
```
@Nullable
public static LocalTime getWithMillisOnly(@Nullable
                                          LocalTime a)
```
Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source time. May be null.

Returns:

null if the parameter is null, the local time with microseconds and nanoseconds set to 0 otherwise.

Since:

9.4.7

getCurrentLocalTimeMillisOnly
```
@Nonnegative
public static LocalTime getCurrentLocalTimeMillisOnly()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Since:

9.4.7

getCurrentLocalTimeMillisOnlyUTC
```
@Nonnegative
public static LocalTime getCurrentLocalTimeMillisOnlyUTC()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        GregorianCalendar a)

createLocalTime

@Nonnull
public static LocalTime createLocalTime(long nMillis)

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        Instant a)

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        Date a)

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        LocalDateTime a)

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        OffsetTime a)

createLocalTime

@Nullable
public static LocalTime createLocalTime(@Nullable
                                        XMLOffsetTime a)

createLocalTime

@Nonnull
public static LocalTime createLocalTime(int nHour,
                                        int nMinute,
                                        int nSecond)

getCurrentOffsetTime

@Nonnegative
public static OffsetTime getCurrentOffsetTime()

getCurrentOffsetTimeUTC

@Nonnegative
public static OffsetTime getCurrentOffsetTimeUTC()

getWithMillisOnly
```
@Nullable
public static OffsetTime getWithMillisOnly(@Nullable
                                           OffsetTime a)
```
Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source time. May be null.

Returns:

null if the parameter is null, the local time with microseconds and nanoseconds set to 0 otherwise.

Since:

10.0.0

getCurrentOffsetTimeMillisOnly
```
@Nonnegative
public static OffsetTime getCurrentOffsetTimeMillisOnly()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Since:

9.4.7

getCurrentOffsetTimeMillisOnlyUTC
```
@Nonnegative
public static OffsetTime getCurrentOffsetTimeMillisOnlyUTC()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          GregorianCalendar a)

createOffsetTime

@Nonnull
public static OffsetTime createOffsetTime(long nMillis)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          Instant a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          Date a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          OffsetDateTime a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          ZonedDateTime a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          LocalDateTime a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          LocalDateTime a,
                                          @Nonnull
                                          ZoneOffset aOfs)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          LocalTime a)

createOffsetTime

@Nullable
public static OffsetTime createOffsetTime(@Nullable
                                          LocalTime a,
                                          @Nonnull
                                          ZoneOffset aOfs)

createOffsetTime

@Nonnull
public static OffsetTime createOffsetTime(int nHour,
                                          int nMinute,
                                          int nSecond,
                                          @Nonnull
                                          ZoneOffset aOfs)

getCurrentXMLOffsetTime

@Nonnegative
public static XMLOffsetTime getCurrentXMLOffsetTime()

getCurrentXMLOffsetTimeUTC

@Nonnegative
public static XMLOffsetTime getCurrentXMLOffsetTimeUTC()

getWithMillisOnly
```
@Nullable
public static XMLOffsetTime getWithMillisOnly(@Nullable
                                              XMLOffsetTime a)
```
Get the passed time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

Parameters:

a - Source time. May be null.

Returns:

null if the parameter is null, the local time with microseconds and nanoseconds set to 0 otherwise.

getCurrentXMLOffsetTimeMillisOnly
```
@Nonnegative
public static XMLOffsetTime getCurrentXMLOffsetTimeMillisOnly()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

getCurrentXMLOffsetTimeMillisOnlyUTC
```
@Nonnegative
public static XMLOffsetTime getCurrentXMLOffsetTimeMillisOnlyUTC()
```
Returns:

The current local time but with micro and nanoseconds set to 0, so that only the milliseconds part is present. This is helpful for XSD serialization, where only milliseconds granularity is available.

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                GregorianCalendar a)

createXMLOffsetTime

@Nonnull
public static XMLOffsetTime createXMLOffsetTime(long nMillis)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                Instant a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                Date a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                OffsetDateTime a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                ZonedDateTime a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                LocalDateTime a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                LocalDateTime a,
                                                @Nullable
                                                ZoneOffset aOfs)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                LocalTime a)

createXMLOffsetTime

@Nullable
public static XMLOffsetTime createXMLOffsetTime(@Nullable
                                                LocalTime a,
                                                @Nullable
                                                ZoneOffset aOfs)

createXMLOffsetTime

@Nonnull
public static XMLOffsetTime createXMLOffsetTime(int nHour,
                                                int nMinute,
                                                int nSecond)

createXMLOffsetTime

@Nonnull
public static XMLOffsetTime createXMLOffsetTime(int nHour,
                                                int nMinute,
                                                int nSecond,
                                                @Nullable
                                                ZoneOffset aOfs)

createDate

@Nullable
public static Date createDate(@Nullable
                              ZonedDateTime a)

createDate

@Nullable
public static Date createDate(@Nullable
                              OffsetDateTime a)

createDate

@Nullable
public static Date createDate(@Nullable
                              LocalDateTime a)

createDate

@Nullable
public static Date createDate(@Nullable
                              LocalDate a)

createDate

@Nullable
public static Date createDate(@Nullable
                              OffsetDate aOD)

createDate

@Nullable
public static Date createDate(@Nullable
                              XMLOffsetDate aOD)

createDate

@Nullable
public static Date createDate(@Nullable
                              LocalTime a)

createDate

@Nullable
public static Date createDate(@Nullable
                              OffsetTime a)

createDate

@Nullable
public static Date createDate(@Nullable
                              XMLOffsetTime a)

createDateForDate

@Nonnull
public static Date createDateForDate(int nYear,
                                     @Nonnull
                                     Month eMonth,
                                     int nDayOfMonth)

createDateForTime

@Nonnull
public static Date createDateForTime(int nHour,
                                     int nMin,
                                     int nSec)

createCalendar

@Nonnull
public static Calendar createCalendar()

createCalendarUTC

@Nonnull
public static Calendar createCalendarUTC()

createGregorianCalendar

@Nonnull
public static GregorianCalendar createGregorianCalendar()

createGregorianCalendarUTC

@Nonnull
public static GregorianCalendar createGregorianCalendarUTC()

getCurrentYear

@Nonnegative
public static int getCurrentYear()

getCurrentYearUTC

@Nonnegative
public static int getCurrentYearUTC()

getCurrentYearObj

@Nonnull
public static Year getCurrentYearObj()

getCurrentYearObjUTC

@Nonnull
public static Year getCurrentYearObjUTC()

getCurrentMonthDay

@Nonnull
public static MonthDay getCurrentMonthDay()

getCurrentMonthDayUTC

@Nonnull
public static MonthDay getCurrentMonthDayUTC()

getCurrentYearMonth

@Nonnegative
public static YearMonth getCurrentYearMonth()

getCurrentYearMonthUTC

@Nonnegative
public static YearMonth getCurrentYearMonthUTC()

getCurrentInstant

@Nonnegative
public static Instant getCurrentInstant()

getCurrentInstantUTC

@Nonnegative
public static Instant getCurrentInstantUTC()

getCurrentMillis
```
public static long getCurrentMillis()
```

getCurrentMillisUTC

public static long getCurrentMillisUTC()

getMillis

public static long getMillis(@Nonnull
                             LocalDate a)

getMillis

public static long getMillis(@Nonnull
                             OffsetDate aOD)

getMillis

public static long getMillis(@Nonnull
                             XMLOffsetDate aOD)

getMillis

public static long getMillis(@Nonnull
                             LocalTime a)

getMillis

public static long getMillis(@Nonnull
                             OffsetTime a)

getMillis

public static long getMillis(@Nonnull
                             XMLOffsetTime a)

getMillis

public static long getMillis(@Nonnull
                             LocalDateTime a)

getMillis

public static long getMillis(@Nonnull
                             OffsetDateTime a)

getMillis

public static long getMillis(@Nonnull
                             XMLOffsetDateTime a)

getMillis

public static long getMillis(@Nonnull
                             ZonedDateTime a)

Class PDTFactory

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getTimezoneOffsetInMinutes

getTimezoneOffsetInMinutes

getTimezoneOffsetInMinutes

getTimezoneOffsetInMinutes

getZoneOffsetFromOffsetInMinutes

getZoneOffset

getZoneIdFromOffsetInMinutes

getZoneId

getTimeZone

getCurrentZonedDateTime

getCurrentZonedDateTimeUTC

getWithMillisOnly

getCurrentZonedDateTimeMillisOnly

getCurrentZonedDateTimeMillisOnlyUTC

createZonedDateTime

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTime

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTime

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTime

createZonedDateTime

createZonedDateTime

createZonedDateTimeUTC

createZonedDateTime

createZonedDateTimeUTC

getCurrentOffsetDateTime

getCurrentOffsetDateTimeUTC

getWithMillisOnly

getCurrentOffsetDateTimeMillisOnly

getCurrentOffsetDateTimeMillisOnlyUTC

createOffsetDateTime

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTime

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTime

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTime

createOffsetDateTime

createOffsetDateTime

createOffsetDateTimeUTC

createOffsetDateTime

createOffsetDateTimeUTC