use of java.time.temporal.UnsupportedTemporalTypeException in project lucene-solr by apache.
the class TemporalEvaluator method evaluate.
@Override
public Object evaluate(Tuple tuple) throws IOException {
Instant instant = null;
TemporalAccessor date = null;
//First evaluate the parameter
StreamEvaluator streamEvaluator = subEvaluators.get(0);
Object tupleValue = streamEvaluator.evaluate(tuple);
if (tupleValue == null)
return null;
if (field == null) {
field = streamEvaluator.toExpression(constructingFactory).toString();
}
Map tupleContext = streamContext.getTupleContext();
// Check to see if the date has already been created for this field
date = (LocalDateTime) tupleContext.get(field);
if (date == null) {
if (tupleValue instanceof String) {
instant = getInstant((String) tupleValue);
} else if (tupleValue instanceof Long) {
instant = Instant.ofEpochMilli((Long) tupleValue);
} else if (tupleValue instanceof Instant) {
instant = (Instant) tupleValue;
} else if (tupleValue instanceof Date) {
instant = ((Date) tupleValue).toInstant();
} else if (tupleValue instanceof TemporalAccessor) {
date = ((TemporalAccessor) tupleValue);
// Cache the date in the TupleContext
tupleContext.put(field, date);
}
}
if (instant != null) {
if (TemporalEvaluatorEpoch.FUNCTION_NAME.equals(getFunction()))
return instant.toEpochMilli();
date = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
// Cache the date in the TupleContext
tupleContext.put(field, date);
}
if (date != null) {
try {
return evaluateDate(date);
} catch (UnsupportedTemporalTypeException utte) {
throw new IOException(String.format(Locale.ROOT, "It is not possible to call '%s' function on %s", getFunction(), date.getClass().getName()));
}
}
throw new IOException(String.format(Locale.ROOT, "Invalid parameter %s - The parameter must be a string formatted ISO_INSTANT or of type Long,Instant,Date,LocalDateTime or TemporalAccessor.", String.valueOf(tupleValue)));
}
use of java.time.temporal.UnsupportedTemporalTypeException in project jdk8u_jdk by JetBrains.
the class HijrahDate method with.
@Override
public HijrahDate with(TemporalField field, long newValue) {
if (field instanceof ChronoField) {
ChronoField f = (ChronoField) field;
// not using checkValidIntValue so EPOCH_DAY and PROLEPTIC_MONTH work
// TODO: validate value
chrono.range(f).checkValidValue(newValue, f);
int nvalue = (int) newValue;
switch(f) {
case DAY_OF_WEEK:
return plusDays(newValue - getDayOfWeek());
case ALIGNED_DAY_OF_WEEK_IN_MONTH:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_MONTH));
case ALIGNED_DAY_OF_WEEK_IN_YEAR:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_YEAR));
case DAY_OF_MONTH:
return resolvePreviousValid(prolepticYear, monthOfYear, nvalue);
case DAY_OF_YEAR:
return plusDays(Math.min(nvalue, lengthOfYear()) - getDayOfYear());
case EPOCH_DAY:
return new HijrahDate(chrono, newValue);
case ALIGNED_WEEK_OF_MONTH:
return plusDays((newValue - getLong(ALIGNED_WEEK_OF_MONTH)) * 7);
case ALIGNED_WEEK_OF_YEAR:
return plusDays((newValue - getLong(ALIGNED_WEEK_OF_YEAR)) * 7);
case MONTH_OF_YEAR:
return resolvePreviousValid(prolepticYear, nvalue, dayOfMonth);
case PROLEPTIC_MONTH:
return plusMonths(newValue - getProlepticMonth());
case YEAR_OF_ERA:
return resolvePreviousValid(prolepticYear >= 1 ? nvalue : 1 - nvalue, monthOfYear, dayOfMonth);
case YEAR:
return resolvePreviousValid(nvalue, monthOfYear, dayOfMonth);
case ERA:
return resolvePreviousValid(1 - prolepticYear, monthOfYear, dayOfMonth);
}
throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
}
return super.with(field, newValue);
}
use of java.time.temporal.UnsupportedTemporalTypeException in project jdk8u_jdk by JetBrains.
the class LocalTime method with.
/**
* Returns a copy of this time with the specified field set to a new value.
* <p>
* This returns a {@code LocalTime}, based on this one, with the value
* for the specified field changed.
* This can be used to change any supported field, such as the hour, minute or second.
* If it is not possible to set the value, because the field is not supported or for
* some other reason, an exception is thrown.
* <p>
* If the field is a {@link ChronoField} then the adjustment is implemented here.
* The supported fields behave as follows:
* <ul>
* <li>{@code NANO_OF_SECOND} -
* Returns a {@code LocalTime} with the specified nano-of-second.
* The hour, minute and second will be unchanged.
* <li>{@code NANO_OF_DAY} -
* Returns a {@code LocalTime} with the specified nano-of-day.
* This completely replaces the time and is equivalent to {@link #ofNanoOfDay(long)}.
* <li>{@code MICRO_OF_SECOND} -
* Returns a {@code LocalTime} with the nano-of-second replaced by the specified
* micro-of-second multiplied by 1,000.
* The hour, minute and second will be unchanged.
* <li>{@code MICRO_OF_DAY} -
* Returns a {@code LocalTime} with the specified micro-of-day.
* This completely replaces the time and is equivalent to using {@link #ofNanoOfDay(long)}
* with the micro-of-day multiplied by 1,000.
* <li>{@code MILLI_OF_SECOND} -
* Returns a {@code LocalTime} with the nano-of-second replaced by the specified
* milli-of-second multiplied by 1,000,000.
* The hour, minute and second will be unchanged.
* <li>{@code MILLI_OF_DAY} -
* Returns a {@code LocalTime} with the specified milli-of-day.
* This completely replaces the time and is equivalent to using {@link #ofNanoOfDay(long)}
* with the milli-of-day multiplied by 1,000,000.
* <li>{@code SECOND_OF_MINUTE} -
* Returns a {@code LocalTime} with the specified second-of-minute.
* The hour, minute and nano-of-second will be unchanged.
* <li>{@code SECOND_OF_DAY} -
* Returns a {@code LocalTime} with the specified second-of-day.
* The nano-of-second will be unchanged.
* <li>{@code MINUTE_OF_HOUR} -
* Returns a {@code LocalTime} with the specified minute-of-hour.
* The hour, second-of-minute and nano-of-second will be unchanged.
* <li>{@code MINUTE_OF_DAY} -
* Returns a {@code LocalTime} with the specified minute-of-day.
* The second-of-minute and nano-of-second will be unchanged.
* <li>{@code HOUR_OF_AMPM} -
* Returns a {@code LocalTime} with the specified hour-of-am-pm.
* The AM/PM, minute-of-hour, second-of-minute and nano-of-second will be unchanged.
* <li>{@code CLOCK_HOUR_OF_AMPM} -
* Returns a {@code LocalTime} with the specified clock-hour-of-am-pm.
* The AM/PM, minute-of-hour, second-of-minute and nano-of-second will be unchanged.
* <li>{@code HOUR_OF_DAY} -
* Returns a {@code LocalTime} with the specified hour-of-day.
* The minute-of-hour, second-of-minute and nano-of-second will be unchanged.
* <li>{@code CLOCK_HOUR_OF_DAY} -
* Returns a {@code LocalTime} with the specified clock-hour-of-day.
* The minute-of-hour, second-of-minute and nano-of-second will be unchanged.
* <li>{@code AMPM_OF_DAY} -
* Returns a {@code LocalTime} with the specified AM/PM.
* The hour-of-am-pm, minute-of-hour, second-of-minute and nano-of-second will be unchanged.
* </ul>
* <p>
* In all cases, if the new value is outside the valid range of values for the field
* then a {@code DateTimeException} will be thrown.
* <p>
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}
* passing {@code this} as the argument. In this case, the field determines
* whether and how to adjust the instant.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param field the field to set in the result, not null
* @param newValue the new value of the field in the result
* @return a {@code LocalTime} based on {@code this} with the specified field set, not null
* @throws DateTimeException if the field cannot be set
* @throws UnsupportedTemporalTypeException if the field is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public LocalTime with(TemporalField field, long newValue) {
if (field instanceof ChronoField) {
ChronoField f = (ChronoField) field;
f.checkValidValue(newValue);
switch(f) {
case NANO_OF_SECOND:
return withNano((int) newValue);
case NANO_OF_DAY:
return LocalTime.ofNanoOfDay(newValue);
case MICRO_OF_SECOND:
return withNano((int) newValue * 1000);
case MICRO_OF_DAY:
return LocalTime.ofNanoOfDay(newValue * 1000);
case MILLI_OF_SECOND:
return withNano((int) newValue * 1000_000);
case MILLI_OF_DAY:
return LocalTime.ofNanoOfDay(newValue * 1000_000);
case SECOND_OF_MINUTE:
return withSecond((int) newValue);
case SECOND_OF_DAY:
return plusSeconds(newValue - toSecondOfDay());
case MINUTE_OF_HOUR:
return withMinute((int) newValue);
case MINUTE_OF_DAY:
return plusMinutes(newValue - (hour * 60 + minute));
case HOUR_OF_AMPM:
return plusHours(newValue - (hour % 12));
case CLOCK_HOUR_OF_AMPM:
return plusHours((newValue == 12 ? 0 : newValue) - (hour % 12));
case HOUR_OF_DAY:
return withHour((int) newValue);
case CLOCK_HOUR_OF_DAY:
return withHour((int) (newValue == 24 ? 0 : newValue));
case AMPM_OF_DAY:
return plusHours((newValue - (hour / 12)) * 12);
}
throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
}
return field.adjustInto(this, newValue);
}
use of java.time.temporal.UnsupportedTemporalTypeException in project jdk8u_jdk by JetBrains.
the class LocalDate method with.
/**
* Returns a copy of this date with the specified field set to a new value.
* <p>
* This returns a {@code LocalDate}, based on this one, with the value
* for the specified field changed.
* This can be used to change any supported field, such as the year, month or day-of-month.
* If it is not possible to set the value, because the field is not supported or for
* some other reason, an exception is thrown.
* <p>
* In some cases, changing the specified field can cause the resulting date to become invalid,
* such as changing the month from 31st January to February would make the day-of-month invalid.
* In cases like this, the field is responsible for resolving the date. Typically it will choose
* the previous valid date, which would be the last valid day of February in this example.
* <p>
* If the field is a {@link ChronoField} then the adjustment is implemented here.
* The supported fields behave as follows:
* <ul>
* <li>{@code DAY_OF_WEEK} -
* Returns a {@code LocalDate} with the specified day-of-week.
* The date is adjusted up to 6 days forward or backward within the boundary
* of a Monday to Sunday week.
* <li>{@code ALIGNED_DAY_OF_WEEK_IN_MONTH} -
* Returns a {@code LocalDate} with the specified aligned-day-of-week.
* The date is adjusted to the specified month-based aligned-day-of-week.
* Aligned weeks are counted such that the first week of a given month starts
* on the first day of that month.
* This may cause the date to be moved up to 6 days into the following month.
* <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} -
* Returns a {@code LocalDate} with the specified aligned-day-of-week.
* The date is adjusted to the specified year-based aligned-day-of-week.
* Aligned weeks are counted such that the first week of a given year starts
* on the first day of that year.
* This may cause the date to be moved up to 6 days into the following year.
* <li>{@code DAY_OF_MONTH} -
* Returns a {@code LocalDate} with the specified day-of-month.
* The month and year will be unchanged. If the day-of-month is invalid for the
* year and month, then a {@code DateTimeException} is thrown.
* <li>{@code DAY_OF_YEAR} -
* Returns a {@code LocalDate} with the specified day-of-year.
* The year will be unchanged. If the day-of-year is invalid for the
* year, then a {@code DateTimeException} is thrown.
* <li>{@code EPOCH_DAY} -
* Returns a {@code LocalDate} with the specified epoch-day.
* This completely replaces the date and is equivalent to {@link #ofEpochDay(long)}.
* <li>{@code ALIGNED_WEEK_OF_MONTH} -
* Returns a {@code LocalDate} with the specified aligned-week-of-month.
* Aligned weeks are counted such that the first week of a given month starts
* on the first day of that month.
* This adjustment moves the date in whole week chunks to match the specified week.
* The result will have the same day-of-week as this date.
* This may cause the date to be moved into the following month.
* <li>{@code ALIGNED_WEEK_OF_YEAR} -
* Returns a {@code LocalDate} with the specified aligned-week-of-year.
* Aligned weeks are counted such that the first week of a given year starts
* on the first day of that year.
* This adjustment moves the date in whole week chunks to match the specified week.
* The result will have the same day-of-week as this date.
* This may cause the date to be moved into the following year.
* <li>{@code MONTH_OF_YEAR} -
* Returns a {@code LocalDate} with the specified month-of-year.
* The year will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* <li>{@code PROLEPTIC_MONTH} -
* Returns a {@code LocalDate} with the specified proleptic-month.
* The day-of-month will be unchanged, unless it would be invalid for the new month
* and year. In that case, the day-of-month is adjusted to the maximum valid value
* for the new month and year.
* <li>{@code YEAR_OF_ERA} -
* Returns a {@code LocalDate} with the specified year-of-era.
* The era and month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* <li>{@code YEAR} -
* Returns a {@code LocalDate} with the specified year.
* The month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* <li>{@code ERA} -
* Returns a {@code LocalDate} with the specified era.
* The year-of-era and month will be unchanged. The day-of-month will also be unchanged,
* unless it would be invalid for the new month and year. In that case, the
* day-of-month is adjusted to the maximum valid value for the new month and year.
* </ul>
* <p>
* In all cases, if the new value is outside the valid range of values for the field
* then a {@code DateTimeException} will be thrown.
* <p>
* All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
* <p>
* If the field is not a {@code ChronoField}, then the result of this method
* is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)}
* passing {@code this} as the argument. In this case, the field determines
* whether and how to adjust the instant.
* <p>
* This instance is immutable and unaffected by this method call.
*
* @param field the field to set in the result, not null
* @param newValue the new value of the field in the result
* @return a {@code LocalDate} based on {@code this} with the specified field set, not null
* @throws DateTimeException if the field cannot be set
* @throws UnsupportedTemporalTypeException if the field is not supported
* @throws ArithmeticException if numeric overflow occurs
*/
@Override
public LocalDate with(TemporalField field, long newValue) {
if (field instanceof ChronoField) {
ChronoField f = (ChronoField) field;
f.checkValidValue(newValue);
switch(f) {
case DAY_OF_WEEK:
return plusDays(newValue - getDayOfWeek().getValue());
case ALIGNED_DAY_OF_WEEK_IN_MONTH:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_MONTH));
case ALIGNED_DAY_OF_WEEK_IN_YEAR:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_YEAR));
case DAY_OF_MONTH:
return withDayOfMonth((int) newValue);
case DAY_OF_YEAR:
return withDayOfYear((int) newValue);
case EPOCH_DAY:
return LocalDate.ofEpochDay(newValue);
case ALIGNED_WEEK_OF_MONTH:
return plusWeeks(newValue - getLong(ALIGNED_WEEK_OF_MONTH));
case ALIGNED_WEEK_OF_YEAR:
return plusWeeks(newValue - getLong(ALIGNED_WEEK_OF_YEAR));
case MONTH_OF_YEAR:
return withMonth((int) newValue);
case PROLEPTIC_MONTH:
return plusMonths(newValue - getProlepticMonth());
case YEAR_OF_ERA:
return withYear((int) (year >= 1 ? newValue : 1 - newValue));
case YEAR:
return withYear((int) newValue);
case ERA:
return (getLong(ERA) == newValue ? this : withYear(1 - year));
}
throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
}
return field.adjustInto(this, newValue);
}
use of java.time.temporal.UnsupportedTemporalTypeException in project jdk8u_jdk by JetBrains.
the class CopticDate method with.
@Override
public CopticDate with(TemporalField field, long newValue) {
if (field instanceof ChronoField) {
ChronoField f = (ChronoField) field;
// TODO: validate value
f.checkValidValue(newValue);
int nvalue = (int) newValue;
switch(f) {
case DAY_OF_WEEK:
return plusDays(newValue - get(ChronoField.DAY_OF_WEEK));
case ALIGNED_DAY_OF_WEEK_IN_MONTH:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_MONTH));
case ALIGNED_DAY_OF_WEEK_IN_YEAR:
return plusDays(newValue - getLong(ALIGNED_DAY_OF_WEEK_IN_YEAR));
case DAY_OF_MONTH:
return resolvePreviousValid(prolepticYear, month, nvalue);
case DAY_OF_YEAR:
return resolvePreviousValid(prolepticYear, ((nvalue - 1) / 30) + 1, ((nvalue - 1) % 30) + 1);
case EPOCH_DAY:
return ofEpochDay(nvalue);
case ALIGNED_WEEK_OF_MONTH:
return plusDays((newValue - getLong(ALIGNED_WEEK_OF_MONTH)) * 7);
case ALIGNED_WEEK_OF_YEAR:
return plusDays((newValue - getLong(ALIGNED_WEEK_OF_YEAR)) * 7);
case MONTH_OF_YEAR:
return resolvePreviousValid(prolepticYear, nvalue, day);
case YEAR_OF_ERA:
return resolvePreviousValid(prolepticYear >= 1 ? nvalue : 1 - nvalue, month, day);
case YEAR:
return resolvePreviousValid(nvalue, month, day);
case ERA:
return resolvePreviousValid(1 - prolepticYear, month, day);
}
throw new UnsupportedTemporalTypeException("Unsupported field: " + field);
}
return field.adjustInto(this, newValue);
}
Aggregations