/** * Normalizes the time-zone ID, returning a {@code ZoneOffset} where possible. * <p> * The returns a normalized {@code ZoneId} that can be used in place of this ID. * The result will have {@code ZoneRules} equivalent to those returned by this object, * however the ID returned by {@code getId()} may be different. * <p> * The normalization checks if the rules of this {@code ZoneId} have a fixed offset. * If they do, then the {@code ZoneOffset} equal to that offset is returned. * Otherwise {@code this} is returned. * * @return the time-zone unique ID, not null */ public ZoneId normalized() { try { ZoneRules rules = getRules(); if (rules.isFixedOffset()) { return rules.getOffset(Instant.EPOCH); } } catch (ZoneRulesException ex) { // ignore invalid objects } return this; }
@Override public OffsetDateTime apply(OffsetDateTime d, ZoneId z) { return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime())); } }
@Override public OffsetDateTime apply(OffsetDateTime d, ZoneId z) { return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime())); } }
@Override public OffsetDateTime apply(OffsetDateTime d, ZoneId z) { return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime())); } },
@Override public OffsetDateTime apply(OffsetDateTime d, ZoneId z) { return d.withOffsetSameInstant(z.getRules().getOffset(d.toLocalDateTime())); } }
/** * Obtains an instance of {@code ZonedDateTime} using seconds from the * epoch of 1970-01-01T00:00:00Z. * * @param epochSecond the number of seconds from the epoch of 1970-01-01T00:00:00Z * @param nanoOfSecond the nanosecond within the second, from 0 to 999,999,999 * @param zone the time-zone, not null * @return the zoned date-time, not null * @throws DateTimeException if the result exceeds the supported range */ private static ZonedDateTime create(long epochSecond, int nanoOfSecond, ZoneId zone) { ZoneRules rules = zone.getRules(); Instant instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond); // TODO: rules should be queryable by epochSeconds ZoneOffset offset = rules.getOffset(instant); LocalDateTime ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset); return new ZonedDateTime(ldt, offset, zone); }
/** * Obtains an instance of {@code ZonedDateTime} using seconds from the * epoch of 1970-01-01T00:00:00Z. * * @param epochSecond the number of seconds from the epoch of 1970-01-01T00:00:00Z * @param nanoOfSecond the nanosecond within the second, from 0 to 999,999,999 * @param zone the time-zone, not null * @return the zoned date-time, not null * @throws DateTimeException if the result exceeds the supported range */ private static ZonedDateTime create(long epochSecond, int nanoOfSecond, ZoneId zone) { ZoneRules rules = zone.getRules(); Instant instant = Instant.ofEpochSecond(epochSecond, nanoOfSecond); // TODO: rules should be queryable by epochSeconds ZoneOffset offset = rules.getOffset(instant); LocalDateTime ldt = LocalDateTime.ofEpochSecond(epochSecond, nanoOfSecond, offset); return new ZonedDateTime(ldt, offset, zone); }
/** * Obtains the current date-time from the specified clock. * <p> * This will query the specified clock to obtain the current date-time. * The offset will be calculated from the time-zone in the clock. * <p> * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date-time, not null */ public static OffsetDateTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once return ofInstant(now, clock.getZone().getRules().getOffset(now)); }
/** * Obtains the current time from the specified clock. * <p> * This will query the specified clock to obtain the current time. * The offset will be calculated from the time-zone in the clock. * <p> * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current time, not null */ public static OffsetTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once return ofInstant(now, clock.getZone().getRules().getOffset(now)); }
/** * Obtains the current time from the specified clock. * <p> * This will query the specified clock to obtain the current time. * The offset will be calculated from the time-zone in the clock. * <p> * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current time, not null */ public static OffsetTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once return ofInstant(now, clock.getZone().getRules().getOffset(now)); }
/** * Obtains the current date-time from the specified clock. * <p> * This will query the specified clock to obtain the current date-time. * The offset will be calculated from the time-zone in the clock. * <p> * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date-time, not null */ public static OffsetDateTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once return ofInstant(now, clock.getZone().getRules().getOffset(now)); }
/** * Obtains an instance of {@code LocalDateTime} from an {@code Instant} and zone ID. * <p> * This creates a local date-time based on the specified instant. * First, the offset from UTC/Greenwich is obtained using the zone ID and instant, * which is simple as there is only one valid offset for each instant. * Then, the instant and offset are used to calculate the local date-time. * * @param instant the instant to create the date-time from, not null * @param zone the time-zone, which may be an offset, not null * @return the local date-time, not null * @throws DateTimeException if the result exceeds the supported range */ public static LocalDateTime ofInstant(Instant instant, ZoneId zone) { Jdk8Methods.requireNonNull(instant, "instant"); Jdk8Methods.requireNonNull(zone, "zone"); ZoneRules rules = zone.getRules(); ZoneOffset offset = rules.getOffset(instant); return ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset); }
/** * Obtains the current date-time from the specified clock. * <p> * This will query the specified clock to obtain the current date-time. * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date-time, not null */ public static LocalDateTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once ZoneOffset offset = clock.getZone().getRules().getOffset(now); return ofEpochSecond(now.getEpochSecond(), now.getNano(), offset); }
/** * Obtains an instance from an instant using the specified time-zone. * * @param chrono the chronology, not null * @param instant the instant, not null * @param zone the zone identifier, not null * @return the zoned date-time, not null */ static <R extends ChronoLocalDate> ChronoZonedDateTimeImpl<R> ofInstant(Chronology chrono, Instant instant, ZoneId zone) { ZoneRules rules = zone.getRules(); ZoneOffset offset = rules.getOffset(instant); Jdk8Methods.requireNonNull(offset, "offset"); // protect against bad ZoneRules LocalDateTime ldt = LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset); @SuppressWarnings("unchecked") ChronoLocalDateTimeImpl<R> cldt = (ChronoLocalDateTimeImpl<R>) chrono.localDateTime(ldt); return new ChronoZonedDateTimeImpl<R>(cldt, offset, zone); }
/** * Obtains the current date-time from the specified clock. * <p> * This will query the specified clock to obtain the current date-time. * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date-time, not null */ public static LocalDateTime now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once ZoneOffset offset = clock.getZone().getRules().getOffset(now); return ofEpochSecond(now.getEpochSecond(), now.getNano(), offset); }
/** * Obtains an instance from an instant using the specified time-zone. * * @param chrono the chronology, not null * @param instant the instant, not null * @param zone the zone identifier, not null * @return the zoned date-time, not null */ static <R extends ChronoLocalDate> ChronoZonedDateTimeImpl<R> ofInstant(Chronology chrono, Instant instant, ZoneId zone) { ZoneRules rules = zone.getRules(); ZoneOffset offset = rules.getOffset(instant); Jdk8Methods.requireNonNull(offset, "offset"); // protect against bad ZoneRules LocalDateTime ldt = LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset); @SuppressWarnings("unchecked") ChronoLocalDateTimeImpl<R> cldt = (ChronoLocalDateTimeImpl<R>) chrono.localDateTime(ldt); return new ChronoZonedDateTimeImpl<R>(cldt, offset, zone); }
/** * Obtains an instance of {@code OffsetDateTime} from an {@code Instant} and zone ID. * <p> * This creates an offset date-time with the same instant as that specified. * Finding the offset from UTC/Greenwich is simple as there is only one valid * offset for each instant. * * @param instant the instant to create the date-time from, not null * @param zone the time-zone, which may be an offset, not null * @return the offset date-time, not null * @throws DateTimeException if the result exceeds the supported range */ public static OffsetDateTime ofInstant(Instant instant, ZoneId zone) { Jdk8Methods.requireNonNull(instant, "instant"); Jdk8Methods.requireNonNull(zone, "zone"); ZoneRules rules = zone.getRules(); ZoneOffset offset = rules.getOffset(instant); LocalDateTime ldt = LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset); return new OffsetDateTime(ldt, offset); }
/** * Obtains an instance of {@code OffsetDateTime} from an {@code Instant} and zone ID. * <p> * This creates an offset date-time with the same instant as that specified. * Finding the offset from UTC/Greenwich is simple as there is only one valid * offset for each instant. * * @param instant the instant to create the date-time from, not null * @param zone the time-zone, which may be an offset, not null * @return the offset date-time, not null * @throws DateTimeException if the result exceeds the supported range */ public static OffsetDateTime ofInstant(Instant instant, ZoneId zone) { Jdk8Methods.requireNonNull(instant, "instant"); Jdk8Methods.requireNonNull(zone, "zone"); ZoneRules rules = zone.getRules(); ZoneOffset offset = rules.getOffset(instant); LocalDateTime ldt = LocalDateTime.ofEpochSecond(instant.getEpochSecond(), instant.getNano(), offset); return new OffsetDateTime(ldt, offset); }
/** * Obtains the current date from the specified clock. * <p> * This will query the specified clock to obtain the current date - today. * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date, not null */ public static LocalDate now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once ZoneOffset offset = clock.getZone().getRules().getOffset(now); long epochSec = now.getEpochSecond() + offset.getTotalSeconds(); // overflow caught later long epochDay = Jdk8Methods.floorDiv(epochSec, SECONDS_PER_DAY); return LocalDate.ofEpochDay(epochDay); }
/** * Obtains the current date from the specified clock. * <p> * This will query the specified clock to obtain the current date - today. * Using this method allows the use of an alternate clock for testing. * The alternate clock may be introduced using {@link Clock dependency injection}. * * @param clock the clock to use, not null * @return the current date, not null */ public static LocalDate now(Clock clock) { Jdk8Methods.requireNonNull(clock, "clock"); final Instant now = clock.instant(); // called once ZoneOffset offset = clock.getZone().getRules().getOffset(now); long epochSec = now.getEpochSecond() + offset.getTotalSeconds(); // overflow caught later long epochDay = Jdk8Methods.floorDiv(epochSec, SECONDS_PER_DAY); return LocalDate.ofEpochDay(epochDay); }