org.threeten.bp.temporal.Temporal Java Examples

@Override
public Temporal addTo(Temporal temporal) {
    Jdk8Methods.requireNonNull(temporal, "temporal");
    Chronology temporalChrono = temporal.query(TemporalQueries.chronology());
    if (temporalChrono != null && chronology.equals(temporalChrono) == false) {
        throw new DateTimeException("Invalid chronology, required: " + chronology.getId() + ", but was: " + temporalChrono.getId());
    }
    if (years != 0) {
        temporal = temporal.plus(years, YEARS);
    }
    if (months != 0) {
        temporal = temporal.plus(months, MONTHS);
    }
    if (days != 0) {
        temporal = temporal.plus(days, DAYS);
    }
    return temporal;
}
 

@Override
public Temporal subtractFrom(Temporal temporal) {
    Jdk8Methods.requireNonNull(temporal, "temporal");
    Chronology temporalChrono = temporal.query(TemporalQueries.chronology());
    if (temporalChrono != null && chronology.equals(temporalChrono) == false) {
        throw new DateTimeException("Invalid chronology, required: " + chronology.getId() + ", but was: " + temporalChrono.getId());
    }
    if (years != 0) {
        temporal = temporal.minus(years, YEARS);
    }
    if (months != 0) {
        temporal = temporal.minus(months, MONTHS);
    }
    if (days != 0) {
        temporal = temporal.minus(days, DAYS);
    }
    return temporal;
}
 

@Test
public void test_with_adjustment() {
    final LocalTime sample = LocalTime.of(23, 5);
    TemporalAdjuster adjuster = new TemporalAdjuster() {
        @Override
        public Temporal adjustInto(Temporal dateTime) {
            return sample;
        }
    };
    assertEquals(TEST_12_30_40_987654321.with(adjuster), sample);
}
 

@Override
public long until(Temporal endExclusive, TemporalUnit unit) {
    @SuppressWarnings("unchecked")
    ChronoZonedDateTime<D> end = (ChronoZonedDateTime<D>) toLocalDate().getChronology().zonedDateTime(endExclusive);
    if (unit instanceof ChronoUnit) {
        end = end.withZoneSameInstant(offset);
        return dateTime.until(end.toLocalDateTime(), unit);
    }
    return unit.between(this, end);
}
 

@Test
public void test_with_adjustment_AmPm() {
    OffsetTime test = TEST_11_30_59_500_PONE.with(new TemporalAdjuster() {
        @Override
        public Temporal adjustInto(Temporal dateTime) {
            return dateTime.with(HOUR_OF_DAY, 23);
        }
    });
    assertEquals(test, OffsetTime.of(LocalTime.of(23, 30, 59, 500), OFFSET_PONE));
}
 

@Test
public void test_with_adjustment() {
    final OffsetTime sample = OffsetTime.of(LocalTime.of(23, 5), OFFSET_PONE);
    TemporalAdjuster adjuster = new TemporalAdjuster() {
        @Override
        public Temporal adjustInto(Temporal dateTime) {
            return sample;
        }
    };
    assertEquals(TEST_11_30_59_500_PONE.with(adjuster), sample);
}
 

/**
 * Casts the {@code Temporal} to {@code ChronoLocalDate} with the same chronology.
 *
 * @param temporal  a date-time to cast, not null
 * @return the date-time checked and cast to {@code ChronoLocalDate}, not null
 * @throws ClassCastException if the date-time cannot be cast to ChronoLocalDate
 *  or the chronology is not equal this Chrono
 */
<D extends ChronoLocalDate> D ensureChronoLocalDate(Temporal temporal) {
    @SuppressWarnings("unchecked")
    D other = (D) temporal;
    if (this.equals(other.getChronology()) == false) {
        throw new ClassCastException("Chrono mismatch, expected: " + getId() + ", actual: " + other.getChronology().getId());
    }
    return other;
}
 

/**
 * Casts the {@code Temporal} to {@code ChronoLocalDateTime} with the same chronology.
 *
 * @param temporal   a date-time to cast, not null
 * @return the date-time checked and cast to {@code ChronoLocalDateTime}, not null
 * @throws ClassCastException if the date-time cannot be cast to ChronoLocalDateTimeImpl
 *  or the chronology is not equal this Chrono
 */
<D extends ChronoLocalDate> ChronoLocalDateTimeImpl<D> ensureChronoLocalDateTime(Temporal temporal) {
    @SuppressWarnings("unchecked")
    ChronoLocalDateTimeImpl<D> other = (ChronoLocalDateTimeImpl<D>) temporal;
    if (this.equals(other.toLocalDate().getChronology()) == false) {
        throw new ClassCastException("Chrono mismatch, required: " + getId()
                + ", supplied: " + other.toLocalDate().getChronology().getId());
    }
    return other;
}
 

/**
 * Casts the {@code Temporal} to {@code ChronoZonedDateTimeImpl} with the same chronology.
 *
 * @param temporal  a date-time to cast, not null
 * @return the date-time checked and cast to {@code ChronoZonedDateTimeImpl}, not null
 * @throws ClassCastException if the date-time cannot be cast to ChronoZonedDateTimeImpl
 *  or the chronology is not equal this Chrono
 */
<D extends ChronoLocalDate> ChronoZonedDateTimeImpl<D> ensureChronoZonedDateTime(Temporal temporal) {
    @SuppressWarnings("unchecked")
    ChronoZonedDateTimeImpl<D> other = (ChronoZonedDateTimeImpl<D>) temporal;
    if (this.equals(other.toLocalDate().getChronology()) == false) {
        throw new ClassCastException("Chrono mismatch, required: " + getId()
                + ", supplied: " + other.toLocalDate().getChronology().getId());
    }
    return other;
}
 

@Test
public void test_with_adjustment() {
    final OffsetDateTime sample = OffsetDateTime.of(LocalDate.of(2012, 3, 4), LocalTime.of(23, 5), OFFSET_PONE);
    TemporalAdjuster adjuster = new TemporalAdjuster() {
        @Override
        public Temporal adjustInto(Temporal dateTime) {
            return sample;
        }
    };
    assertEquals(TEST_2008_6_30_11_30_59_000000500.with(adjuster), sample);
}
 

/**
 * Returns a copy of this date-time with the new date and time, checking
 * to see if a new object is in fact required.
 *
 * @param newDate  the date of the new date-time, not null
 * @param newTime  the time of the new date-time, not null
 * @return the date-time, not null
 */
private ChronoLocalDateTimeImpl<D> with(Temporal newDate, LocalTime newTime) {
    if (date == newDate && time == newTime) {
        return this;
    }
    // Validate that the new DateTime is a ChronoLocalDate (and not something else)
    D cd = date.getChronology().ensureChronoLocalDate(newDate);
    return new ChronoLocalDateTimeImpl<D>(cd, newTime);
}
 

@Override
public long until(Temporal endExclusive, TemporalUnit unit) {
    @SuppressWarnings("unchecked")
    ChronoLocalDateTime<D> end = (ChronoLocalDateTime<D>) toLocalDate().getChronology().localDateTime(endExclusive);
    if (unit instanceof ChronoUnit) {
        ChronoUnit f = (ChronoUnit) unit;
        if (f.isTimeBased()) {
            long amount = end.getLong(EPOCH_DAY) - date.getLong(EPOCH_DAY);
            switch (f) {
                case NANOS: amount = Jdk8Methods.safeMultiply(amount, NANOS_PER_DAY); break;
                case MICROS: amount = Jdk8Methods.safeMultiply(amount, MICROS_PER_DAY); break;
                case MILLIS: amount = Jdk8Methods.safeMultiply(amount, MILLIS_PER_DAY); break;
                case SECONDS: amount = Jdk8Methods.safeMultiply(amount, SECONDS_PER_DAY); break;
                case MINUTES: amount = Jdk8Methods.safeMultiply(amount, MINUTES_PER_DAY); break;
                case HOURS: amount = Jdk8Methods.safeMultiply(amount, HOURS_PER_DAY); break;
                case HALF_DAYS: amount = Jdk8Methods.safeMultiply(amount, 2); break;
            }
            return Jdk8Methods.safeAdd(amount, time.until(end.toLocalTime(), unit));
        }
        ChronoLocalDate endDate = end.toLocalDate();
        if (end.toLocalTime().isBefore(time)) {
            endDate = endDate.minus(1, ChronoUnit.DAYS);
        }
        return date.until(endDate, unit);
    }
    return unit.between(this, end);
}
 

@SuppressWarnings("unchecked")
@Override
public <R extends Temporal> R adjustInto(R dateTime, long newValue) {
    return (R) this.dateTime;
}
 

FixedPeriodUnit(Temporal dateTime) {
    this.dateTime = dateTime;
}
 

@Override
public boolean isSupportedBy(Temporal dateTime) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public Temporal adjustInto(Temporal ignore) {
    return datetime;
}
 

@SuppressWarnings("unchecked")
@Override
public <R extends Temporal> R addTo(R dateTime, long periodToAdd) {
    return (R) this.dateTime;
}
 

@Override
public long between(Temporal temporal1, Temporal temporal2) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

FixedDateTimeField(Temporal dateTime) {
    this.dateTime = dateTime;
}
 

@Override
public Temporal addTo(Temporal ignore) {
    return datetime;
}
 

@Override
public Temporal adjustInto(Temporal ignore) {
    return datetime;
}
 

FixedAdjuster(Temporal datetime) {
    this.datetime = datetime;
}
 

@SuppressWarnings("unchecked")
@Override
public <R extends Temporal> R adjustInto(R dateTime, long newValue) {
    return (R) this.dateTime;
}
 

@Test(expectedExceptions=NullPointerException.class)
public void test_adjustInto_null() {
    DayOfWeek.MONDAY.adjustInto((Temporal) null);
}
 

@Override
public long between(Temporal r, Temporal r2) {
    throw new UnsupportedOperationException();
}
 

@Override
public <R extends Temporal> R addTo(R r, long l) {
    throw new UnsupportedOperationException();
}
 

@Override
public boolean isSupportedBy(Temporal temporal) {
    return false;
}
 

@Override
public long between(Temporal r, Temporal r2) {
    throw new UnsupportedOperationException();
}
 

@Override
public <R extends Temporal> R addTo(R r, long l) {
    throw new UnsupportedOperationException();
}
 

@Override
public boolean isSupportedBy(Temporal temporal) {
    return false;
}