PDTFactory (ph-commons 10.1.6 API)

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 and Description
`static Calendar`	`createCalendar()`
`static Calendar`	`createCalendarUTC()`
`static Date`	`createDate(LocalDate a)`
`static Date`	`createDate(LocalDateTime a)`
`static Date`	`createDate(LocalTime a)`
`static Date`	`createDate(OffsetDate aOD)`
`static Date`	`createDate(OffsetDateTime a)`
`static Date`	`createDate(OffsetTime a)`
`static Date`	`createDate(XMLOffsetDate aOD)`
`static Date`	`createDate(XMLOffsetTime 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(Date a)`
`static LocalDate`	`createLocalDate(GregorianCalendar a)`
`static LocalDate`	`createLocalDate(Instant a)`
`static LocalDate`	`createLocalDate(int nYear, Month eMonth, int nDayOfMonth)`
`static LocalDate`	`createLocalDate(LocalDateTime a)`
`static LocalDate`	`createLocalDate(long nMillis)`
`static LocalDate`	`createLocalDate(Number a)`
`static LocalDate`	`createLocalDate(OffsetDateTime a)`
`static LocalDate`	`createLocalDate(XMLOffsetDate a)`
`static LocalDate`	`createLocalDate(XMLOffsetDateTime a)`
`static LocalDate`	`createLocalDate(Year a)`
`static LocalDate`	`createLocalDate(YearMonth a)`
`static LocalDate`	`createLocalDate(ZonedDateTime a)`
`static LocalDateTime`	`createLocalDateTime(Date a)`
`static LocalDateTime`	`createLocalDateTime(GregorianCalendar aCal)`
`static LocalDateTime`	`createLocalDateTime(Instant 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(LocalDate a)`
`static LocalDateTime`	`createLocalDateTime(LocalTime a)`
`static LocalDateTime`	`createLocalDateTime(long nMillis)`
`static LocalDateTime`	`createLocalDateTime(Number a)`
`static LocalDateTime`	`createLocalDateTime(OffsetDate aDT)`
`static LocalDateTime`	`createLocalDateTime(OffsetDateTime aDT)`
`static LocalDateTime`	`createLocalDateTime(OffsetTime a)`
`static LocalDateTime`	`createLocalDateTime(Timestamp a)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetDate aDT)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetDateTime aDT)`
`static LocalDateTime`	`createLocalDateTime(XMLOffsetTime a)`
`static LocalDateTime`	`createLocalDateTime(Year a)`
`static LocalDateTime`	`createLocalDateTime(YearMonth a)`
`static LocalDateTime`	`createLocalDateTime(ZonedDateTime aDT)`
`static LocalTime`	`createLocalTime(Date a)`
`static LocalTime`	`createLocalTime(GregorianCalendar a)`
`static LocalTime`	`createLocalTime(Instant a)`
`static LocalTime`	`createLocalTime(int nHour, int nMinute, int nSecond)`
`static LocalTime`	`createLocalTime(LocalDateTime a)`
`static LocalTime`	`createLocalTime(long nMillis)`
`static LocalTime`	`createLocalTime(OffsetTime a)`
`static LocalTime`	`createLocalTime(XMLOffsetTime a)`
`static OffsetDate`	`createOffsetDate(Date a)`
`static OffsetDate`	`createOffsetDate(GregorianCalendar a)`
`static OffsetDate`	`createOffsetDate(Instant a)`
`static OffsetDate`	`createOffsetDate(Instant a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(int nYear, Month eMonth, int nDayOfMonth)`
`static OffsetDate`	`createOffsetDate(int nYear, Month eMonth, int nDayOfMonth, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(LocalDate a)`
`static OffsetDate`	`createOffsetDate(LocalDateTime a)`
`static OffsetDate`	`createOffsetDate(LocalDateTime a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(LocalDate a, ZoneOffset aOffset)`
`static OffsetDate`	`createOffsetDate(long nMillis)`
`static OffsetDate`	`createOffsetDate(Number a)`
`static OffsetDate`	`createOffsetDate(OffsetDateTime a)`
`static OffsetDate`	`createOffsetDate(Year a)`
`static OffsetDate`	`createOffsetDate(YearMonth a)`
`static OffsetDate`	`createOffsetDate(ZonedDateTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Date a)`
`static OffsetDateTime`	`createOffsetDateTime(GregorianCalendar aCal)`
`static OffsetDateTime`	`createOffsetDateTime(Instant 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(LocalDate a)`
`static OffsetDateTime`	`createOffsetDateTime(LocalDateTime a)`
`static OffsetDateTime`	`createOffsetDateTime(LocalTime a)`
`static OffsetDateTime`	`createOffsetDateTime(long nMillis)`
`static OffsetDateTime`	`createOffsetDateTime(Number a)`
`static OffsetDateTime`	`createOffsetDateTime(OffsetDate aOD)`
`static OffsetDateTime`	`createOffsetDateTime(OffsetTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Timestamp a)`
`static OffsetDateTime`	`createOffsetDateTime(XMLOffsetDate aOD)`
`static OffsetDateTime`	`createOffsetDateTime(XMLOffsetTime a)`
`static OffsetDateTime`	`createOffsetDateTime(Year a)`
`static OffsetDateTime`	`createOffsetDateTime(YearMonth a)`
`static OffsetDateTime`	`createOffsetDateTime(ZonedDateTime a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Instant a)`
`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(LocalDate a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(LocalDateTime a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(LocalTime a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(long nMillis)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Number a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(Year a)`
`static OffsetDateTime`	`createOffsetDateTimeUTC(YearMonth a)`
`static OffsetTime`	`createOffsetTime(Date a)`
`static OffsetTime`	`createOffsetTime(GregorianCalendar a)`
`static OffsetTime`	`createOffsetTime(Instant a)`
`static OffsetTime`	`createOffsetTime(int nHour, int nMinute, int nSecond, ZoneOffset aOfs)`
`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(long nMillis)`
`static OffsetTime`	`createOffsetTime(OffsetDateTime a)`
`static OffsetTime`	`createOffsetTime(ZonedDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Date a)`
`static XMLOffsetDate`	`createXMLOffsetDate(GregorianCalendar a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Instant a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Instant a, ZoneId aZoneId)`
`static XMLOffsetDate`	`createXMLOffsetDate(int nYear, Month eMonth, int nDayOfMonth)`
`static XMLOffsetDate`	`createXMLOffsetDate(int nYear, Month eMonth, int nDayOfMonth, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDate a)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDateTime a, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(LocalDate a, ZoneOffset aOffset)`
`static XMLOffsetDate`	`createXMLOffsetDate(long nMillis)`
`static XMLOffsetDate`	`createXMLOffsetDate(Number a)`
`static XMLOffsetDate`	`createXMLOffsetDate(OffsetDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(XMLOffsetDateTime a)`
`static XMLOffsetDate`	`createXMLOffsetDate(Year a)`
`static XMLOffsetDate`	`createXMLOffsetDate(YearMonth a)`
`static XMLOffsetDate`	`createXMLOffsetDate(ZonedDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Date a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(GregorianCalendar aCal)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Instant 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(LocalDate a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(LocalDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(LocalTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(long nMillis)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Number a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetDate aOD)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(OffsetTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Timestamp a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(XMLOffsetDate aOD)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(XMLOffsetTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(Year a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(YearMonth a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTime(ZonedDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Instant a)`
`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(LocalDate a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(LocalDateTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(LocalTime a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(long nMillis)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Number a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(Year a)`
`static XMLOffsetDateTime`	`createXMLOffsetDateTimeUTC(YearMonth a)`
`static XMLOffsetTime`	`createXMLOffsetTime(Date a)`
`static XMLOffsetTime`	`createXMLOffsetTime(GregorianCalendar a)`
`static XMLOffsetTime`	`createXMLOffsetTime(Instant a)`
`static XMLOffsetTime`	`createXMLOffsetTime(int nHour, int nMinute, int nSecond)`
`static XMLOffsetTime`	`createXMLOffsetTime(int nHour, int nMinute, int nSecond, ZoneOffset aOfs)`
`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(long nMillis)`
`static XMLOffsetTime`	`createXMLOffsetTime(OffsetDateTime a)`
`static XMLOffsetTime`	`createXMLOffsetTime(ZonedDateTime a)`
`static ZonedDateTime`	`createZonedDateTime(Date a)`
`static ZonedDateTime`	`createZonedDateTime(GregorianCalendar aCal)`
`static ZonedDateTime`	`createZonedDateTime(Instant 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(LocalDate a)`
`static ZonedDateTime`	`createZonedDateTime(LocalDateTime a)`
`static ZonedDateTime`	`createZonedDateTime(LocalTime a)`
`static ZonedDateTime`	`createZonedDateTime(long nMillis)`
`static ZonedDateTime`	`createZonedDateTime(Number a)`
`static ZonedDateTime`	`createZonedDateTime(OffsetDate aOD)`
`static ZonedDateTime`	`createZonedDateTime(OffsetDateTime a)`
`static ZonedDateTime`	`createZonedDateTime(OffsetTime a)`
`static ZonedDateTime`	`createZonedDateTime(Timestamp a)`
`static ZonedDateTime`	`createZonedDateTime(XMLOffsetDate aOD)`
`static ZonedDateTime`	`createZonedDateTime(XMLOffsetTime a)`
`static ZonedDateTime`	`createZonedDateTime(Year a)`
`static ZonedDateTime`	`createZonedDateTime(YearMonth a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(Instant a)`
`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(LocalDate a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(LocalDateTime a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(LocalTime a)`
`static ZonedDateTime`	`createZonedDateTimeUTC(long nMillis)`
`static ZonedDateTime`	`createZonedDateTimeUTC(Number 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(LocalDate a)`
`static long`	`getMillis(LocalDateTime a)`
`static long`	`getMillis(LocalTime a)`
`static long`	`getMillis(OffsetDate aOD)`
`static long`	`getMillis(OffsetDateTime a)`
`static long`	`getMillis(OffsetTime a)`
`static long`	`getMillis(XMLOffsetDate aOD)`
`static long`	`getMillis(XMLOffsetDateTime a)`
`static long`	`getMillis(XMLOffsetTime a)`
`static long`	`getMillis(ZonedDateTime a)`
`static TimeZone`	`getTimeZone(Date a)`
`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 int`	`getTimezoneOffsetInMinutes(ZoneId aZID, Instant aAt)`
`static int`	`getTimezoneOffsetInMinutes(ZoneOffset aZO)`
`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 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 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