Refine search
final LocalDate expectedDate = ((Temporal) expectedValue).query( TemporalQueries.localDate() ); final LocalTime expectedTime = ((Temporal) expectedValue).query( TemporalQueries.localTime() ); final ZoneId expectedZoneId = ((Temporal) expectedValue).query( TemporalQueries.zone() ); LocalDate actualDate = ((Temporal) actualValue).query( TemporalQueries.localDate() ); LocalTime actualTime = ((Temporal) actualValue).query( TemporalQueries.localTime() ); ZoneId actualZoneId = ((Temporal) actualValue).query( TemporalQueries.zone() );
try { TemporalAccessor datetime = formatter.parse(value); ZoneId parsedTimezone = datetime.query(TemporalQueries.zoneId()); ZoneOffset parsedOffset = datetime.query(TemporalQueries.offset()); if (parsedTimezone != null) { return Optional.of(java.time.Instant.from(datetime)); } else if (parsedOffset != null) { try { return Optional.of(java.time.Instant.ofEpochSecond(datetime.getLong(ChronoField.INSTANT_SECONDS))); } catch (UnsupportedTemporalTypeException e) { return Optional.of(java.time.LocalDate.of(
@SuppressWarnings("unchecked") @Override public <R> R query(TemporalQuery<R> query) { if (query == TemporalQueries.precision()) { return (R) ChronoUnit.ERAS; } if (query == TemporalQueries.chronology() || query == TemporalQueries.zone() || query == TemporalQueries.zoneId() || query == TemporalQueries.offset() || query == TemporalQueries.localDate() || query == TemporalQueries.localTime()) { return null; } return query.queryFrom(this); }
@Override public CalendarYear createFrom( TemporalAccessor threeten, AttributeQuery attributes ) { if (threeten.query(TemporalQueries.chronology()) == IsoChronology.INSTANCE) { if (threeten.isSupported(ChronoField.YEAR)) { int year = threeten.get(ChronoField.YEAR); return CalendarYear.of(year); } } return null; }
DateTimeFormatter dtf = dateFormatContainer.getFormatter(); TemporalAccessor accessor = dtf.parse(value); LocalDate ld = accessor.query(TemporalQueries.localDate()); LocalTime lt = accessor.query(TemporalQueries.localTime()); ZoneId zoneId = accessor.query(TemporalQueries.zone()); if (zoneId == null) { zoneId = dtf.getZone();
private static ZonedDateTime parseZonedDateTime(final String text, final DateTimeFormatter formatter, final ZoneId defaultZone){ TemporalAccessor parse = formatter.parse(text); ZoneId zone = parse.query(TemporalQueries.zone()); if (Objects.isNull(zone)) { zone = defaultZone; } int year = parse.isSupported(YEAR) ? parse.get(YEAR) : 0; int month = parse.isSupported(MONTH_OF_YEAR) ? parse.get(MONTH_OF_YEAR) : 0; int day = parse.isSupported(DAY_OF_MONTH) ? parse.get(DAY_OF_MONTH) : 0; int hour = parse.isSupported(HOUR_OF_DAY) ? parse.get(HOUR_OF_DAY) : 0; int minute = parse.isSupported(MINUTE_OF_HOUR) ? parse.get(MINUTE_OF_HOUR) : 0; int second = parse.isSupported(SECOND_OF_MINUTE) ? parse.get(SECOND_OF_MINUTE) : 0; int millisecond = parse.isSupported(MILLI_OF_SECOND) ? parse.get(MILLI_OF_SECOND) : 0; return ZonedDateTime.of(year, month, day, hour, minute, second, millisecond, zone); }
@Override protected XMLGregorianCalendar parseWithFormatter(String jsonValue, DateTimeFormatter formatter) { final TemporalAccessor parsed = formatter.parse(jsonValue); LocalTime time = parsed.query(TemporalQueries.localTime()); ZoneId zone = parsed.query(TemporalQueries.zone()); if (zone == null) { zone = UTC; } if (time == null) { time = ZERO_LOCAL_TIME; } ZonedDateTime result = LocalDate.from(parsed).atTime(time).atZone(zone); return datatypeFactory.newXMLGregorianCalendar(GregorianCalendar.from(result)); } }
public FEELFnResult<TemporalAccessor> invoke(@ParameterName("from") TemporalAccessor date) { if (date == null) { return FEELFnResult.ofError(new InvalidParametersEvent(FEELEvent.Severity.ERROR, "from", "cannot be null")); } try { // If the temporal accessor type doesn't support time, try to parse it as a date with UTC midnight. if (!date.isSupported(ChronoField.HOUR_OF_DAY)) { return BuiltInFunctions.getFunction( DateAndTimeFunction.class ).invoke( date, OffsetTime.of(0, 0, 0, 0, ZoneOffset.UTC) ) .cata( overrideLeft -> FEELFnResult.ofError(new InvalidParametersEvent(FEELEvent.Severity.ERROR, "from", "time-parsing exception")), this::invoke ); } else if( date.query( TemporalQueries.offset() ) == null ) { return FEELFnResult.ofResult(LocalTime.from(date)); } else { ZoneId zone = date.query(TemporalQueries.zoneId()); if (!(zone instanceof ZoneOffset)) { // TZ is a ZoneRegion, so do NOT normalize (although the result will be unreversible, but will keep what was supplied originally). // Unfortunately java.time.Parsed is a package-private class, hence will need to re-parse in order to have it instantiated. return invoke(date.query(TemporalQueries.localTime()) + "@" + zone); } else { return FEELFnResult.ofResult(OffsetTime.from(date)); } } } catch (DateTimeException e) { return FEELFnResult.ofError(new InvalidParametersEvent(FEELEvent.Severity.ERROR, "from", "time-parsing exception", e)); } } }
logger.trace("parsed {} as {}", () -> dateString, () -> ta.toString()); if (! isoChronology.equals(ta.query(TemporalQueries.chronology()).getId())) { logger.warn("Can't hande non ISO chronology"); continue; ZoneId zi = ta.query(TemporalQueries.offset()); if (zi == null) { zi = zone; LocalDate ld = ta.query(TemporalQueries.localDate()); if (ld == null) { ld = LocalDate.now(zi); LocalTime lt = ta.query(TemporalQueries.localTime()); if (lt == null) { lt = LocalTime.now(zi);
/** * Returns the {@link ZoneId} of the given temporal. * If the temporal supports {@link java.time.temporal.ChronoField#OFFSET_SECONDS}, those will be used to define the zone. * Otherwise the temporal will be queried for the zone. Should no zone be provided, {@link ZoneId#systemDefault()} will be used. * * @param temporal to retrieve the ZoneId of * @return the ZoneId. */ private ZoneId getZoneId( TemporalAccessor temporal ) { if ( temporal.isSupported( OFFSET_SECONDS ) ) { return ZoneOffset.ofTotalSeconds( Math.toIntExact( temporal.getLong( OFFSET_SECONDS ) ) ); } ZoneId zone = temporal.query( TemporalQueries.zoneId() ); return ZoneOffset.of( zone != null ? zone.getId() : zoneId.getId(), ZoneId.SHORT_IDS ); }
Instant instant = null; try { if(ta.isSupported(ChronoField.INSTANT_SECONDS) && ta.isSupported(ChronoField.NANO_OF_SECOND)) { instant = Instant.from(ta); LocalDate ld = ta.query(TemporalQueries.localDate()); LocalTime lt = ta.query(TemporalQueries.localTime());
public FEELFnResult<TemporalAccessor> invoke(@ParameterName("from") String val) { if ( val == null ) { return FEELFnResult.ofError(new InvalidParametersEvent(Severity.ERROR, "from", "cannot be null")); } try { TemporalAccessor parsed = FEEL_TIME.parse(val); if (parsed.query(TemporalQueries.offset()) != null) { // it is an offset-zoned time, so I can know for certain an OffsetTime OffsetTime asOffSetTime = parsed.query(OffsetTime::from); return FEELFnResult.ofResult(asOffSetTime); } else if (parsed.query(TemporalQueries.zone()) == null) { // if it does not contain any zone information at all, then I know for certain is a local time. LocalTime asLocalTime = parsed.query(LocalTime::from); return FEELFnResult.ofResult(asLocalTime); } return FEELFnResult.ofResult(parsed); } catch (DateTimeException e) { return FEELFnResult.ofError(new InvalidParametersEvent(Severity.ERROR, "from", e)); } }
static ZoneId parseZoneName( String zoneName ) { ZoneId parsedName; try { parsedName = ZONE_NAME_PARSER.parse( zoneName.replace( ' ', '_' ) ).query( TemporalQueries.zoneId() ); } catch ( DateTimeParseException e ) { throw new TemporalParseException( "Invalid value for TimeZone: " + e.getMessage(), e.getParsedString(), e.getErrorIndex(), e ); } return parsedName; }
/** * Queries this day-of-month using the specified query. * <p> * This queries this day-of-month using the specified query strategy object. * The {@code TemporalQuery} object defines the logic to be used to * obtain the result. Read the documentation of the query to understand * what the result of this method will be. * <p> * The result of this method is obtained by invoking the * {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the * specified query passing {@code this} as the argument. * * @param <R> the type of the result * @param query the query to invoke, not null * @return the query result, null may be returned (defined by the query) * @throws DateTimeException if unable to query (defined by the query) * @throws ArithmeticException if numeric overflow occurs (defined by the query) */ @SuppressWarnings("unchecked") @Override public <R> R query(TemporalQuery<R> query) { if (query == TemporalQueries.chronology()) { return (R) IsoChronology.INSTANCE; } return TemporalAccessor.super.query(query); }
Chronology temporalChrono = temporal.query(TemporalQueries.chronology()); ZoneId temporalZone = temporal.query(TemporalQueries.zoneId()); if (Jdk8Methods.equals(temporalChrono, overrideChrono)) { overrideChrono = null; if (temporal.isSupported(INSTANT_SECONDS)) { Chronology chrono = (effectiveChrono != null ? effectiveChrono : IsoChronology.INSTANCE); return chrono.zonedDateTime(Instant.from(temporal), overrideZone); ZoneOffset temporalOffset = temporal.query(TemporalQueries.offset()); if (normalizedOffset instanceof ZoneOffset && temporalOffset != null && normalizedOffset.equals(temporalOffset) == false) { throw new DateTimeException("Invalid override zone for temporal: " + overrideZone + " " + temporal);
private Optional<ZonedDateTime> getZonedDateTime(TemporalAccessor parsed) { ZoneId zone = parsed.query(TemporalQueries.zone()); if (zone == null) { return Optional.empty(); } Optional<ZonedDateTime> zonedDateTime = getLocalDateTime(parsed) .map(localDateTime -> localDateTime.atZone(zone)); if (!zonedDateTime.isPresent()) { zonedDateTime = getLocalDate(parsed).map(localDate -> localDate.atStartOfDay(zone)); } return zonedDateTime; }
switch ( property ) { case "year": result = ((TemporalAccessor) current).get(ChronoField.YEAR); break; case "month": result = ((TemporalAccessor) current).get(ChronoField.MONTH_OF_YEAR); break; case "day": result = ((TemporalAccessor) current).get(ChronoField.DAY_OF_MONTH); break; case "hour": break; case "timezone": ZoneId zoneId = ((TemporalAccessor) current).query(TemporalQueries.zoneId()); if (zoneId != null) { result = TimeZone.getTimeZone(zoneId).getID();
@Override public SumkDate queryFrom(TemporalAccessor temporal) { if (temporal instanceof LocalDateTime) { return SumkDate.of((LocalDateTime) temporal); } else if (temporal instanceof ZonedDateTime) { LocalDateTime dt = ((ZonedDateTime) temporal).toLocalDateTime(); return SumkDate.of(dt); } else if (temporal instanceof OffsetDateTime) { LocalDateTime dt = ((OffsetDateTime) temporal).toLocalDateTime(); return SumkDate.of(dt); } LocalDate date = temporal.query(TemporalQueries.localDate()); LocalTime time = temporal.query(TemporalQueries.localTime()); if (date == null && time == null) { return null; } return SumkDate.of(date, time); }