/** * Recursively finds repeaters within other repeaters. * Returns a Span representing the innermost time span * or nil if no repeater union could be found */ public static Span findWithin(List<Repeater<?>> tags, Span span, Pointer.PointerType pointer, Options options) { if (options.isDebug()) { System.out.println("Chronic.findWithin: " + tags + " in " + span); } if (tags.isEmpty()) { return span; } Repeater<?> head = tags.get(0); List<Repeater<?>> rest = (tags.size() > 1) ? tags.subList(1, tags.size()) : new LinkedList<Repeater<?>>(); head.setStart((pointer == Pointer.PointerType.FUTURE) ? span.getBeginCalendar() : span.getEndCalendar()); Span h = head.thisSpan(PointerType.NONE); if (span.contains(h.getBegin()) || span.contains(h.getEnd())) { return findWithin(rest, h, pointer, options); } return null; }
@Override public Span getOffset(Span span, int amount, Pointer.PointerType pointer) { int direction = (pointer == Pointer.PointerType.FUTURE) ? 1 : -1; return new Span(Time.cloneAndAdd(span.getBeginCalendar(), Calendar.MONTH, amount * direction), Time.cloneAndAdd(span.getEndCalendar(), Calendar.MONTH, amount * direction)); }
@Override public Span getOffset(Span span, int amount, PointerType pointer) { setStart(span.getBeginCalendar()); Span portionSpan = nextSpan(pointer); int direction = (pointer == Pointer.PointerType.FUTURE) ? 1 : -1; portionSpan = portionSpan.add(direction * (amount - 1) * RepeaterDay.DAY_SECONDS); return portionSpan; }
/** * Guess a specific time within the given span */ // DIFF: We return Span instead of Date protected static Span guess(Span span) { if (span == null) { return null; } long guessValue; if (span.getWidth() > 1) { guessValue = span.getBegin() + (span.getWidth() / 2); } else { guessValue = span.getBegin(); } Span guess = new Span(guessValue, guessValue); return guess; } }
@Override public String toString() { return "(" + DateFormat.getDateTimeInstance().format(getBeginCalendar().getTime()) + ".." + DateFormat.getDateTimeInstance().format(getEndCalendar().getTime()) + ")"; } }
@Override protected Span _thisSpan(PointerType pointer) { Span thisSpan; if (pointer == Pointer.PointerType.FUTURE || pointer == Pointer.PointerType.NONE) { RepeaterDayName saturdayRepeater = new RepeaterDayName(RepeaterDayName.DayName.SATURDAY); saturdayRepeater.setStart((Calendar) getNow().clone()); Span thisSaturdaySpan = saturdayRepeater.nextSpan(Pointer.PointerType.FUTURE); thisSpan = new Span(thisSaturdaySpan.getBeginCalendar(), Time.cloneAndAdd(thisSaturdaySpan.getBeginCalendar(), Calendar.SECOND, RepeaterWeekend.WEEKEND_SECONDS)); } else if (pointer == Pointer.PointerType.PAST) { RepeaterDayName saturdayRepeater = new RepeaterDayName(RepeaterDayName.DayName.SATURDAY); saturdayRepeater.setStart((Calendar) getNow().clone()); Span lastSaturdaySpan = saturdayRepeater.nextSpan(Pointer.PointerType.PAST); thisSpan = new Span(lastSaturdaySpan.getBeginCalendar(), Time.cloneAndAdd(lastSaturdaySpan.getBeginCalendar(), Calendar.SECOND, RepeaterWeekend.WEEKEND_SECONDS)); } else { throw new IllegalArgumentException("Unable to handle pointer " + pointer + "."); } return thisSpan; }
public Span handle(List<Token> tokens, Span outerSpan, Options options) { Repeater<?> repeater = tokens.get(1).getTag(Repeater.class); repeater.setStart(Time.cloneAndAdd(outerSpan.getBeginCalendar(), Calendar.SECOND, -1)); Integer ordinalValue = tokens.get(0).getTag(Ordinal.class).getType(); Span span = null; for (int i = 0; i < ordinalValue.intValue(); i++) { span = repeater.nextSpan(Pointer.PointerType.FUTURE); if (span.getBegin() > outerSpan.getEnd()) { span = null; break; } } return span; } }
@Override public Span getOffset(Span span, int amount, PointerType pointer) { int direction = (pointer == Pointer.PointerType.FUTURE) ? 1 : -1; RepeaterWeekend weekend = new RepeaterWeekend(); weekend.setStart(span.getBeginCalendar()); Calendar start = Time.cloneAndAdd(weekend.nextSpan(pointer).getBeginCalendar(), Calendar.SECOND, (amount - 1) * direction * RepeaterWeek.WEEK_SECONDS); return new Span(start, Time.cloneAndAdd(start, Calendar.SECOND, span.getWidth())); }
@Override protected Span _thisSpan(PointerType pointer) { return new Span(getNow(), Calendar.SECOND, 1); }
public Span handle(Repeater<?> month, Tag<Integer> day, List<Token> timeTokens, Options options) { month.setStart((Calendar) options.getNow().clone()); Span span = month.thisSpan(options.getContext()); Calendar dayStart = Time.construct(span.getBeginCalendar().get(Calendar.YEAR), span.getBeginCalendar().get(Calendar.MONTH) + 1, day.getType().intValue()); return Handler.dayOrTime(dayStart, timeTokens, options); } }
public Calendar getBeginCalendar() { Calendar cal = Calendar.getInstance(); cal.setTimeInMillis(getBegin() * 1000); return cal; }
/** * Subtract a number of seconds to this span, returning the * resulting Span */ public Span subtract(long seconds) { return add(-seconds); }
public Calendar getEndCalendar() { Calendar cal = Calendar.getInstance(); cal.setTimeInMillis(getEnd() * 1000); return cal; }
@Override public int getWidth() { if (_range == null) { throw new IllegalStateException("Range has not been set"); } int width; if (_currentSpan != null) { width = (int) _currentSpan.getWidth(); } else { width = _getWidth(_range); } return width; }
public static Span dayOrTime(Calendar dayStart, List<Token> timeTokens, Options options) { Span outerSpan = new Span(dayStart, Time.cloneAndAdd(dayStart, Calendar.DAY_OF_MONTH, 1)); if (!timeTokens.isEmpty()) { options.setNow(outerSpan.getBeginCalendar()); Span time = getAnchor(dealiasAndDisambiguateTimes(timeTokens, options), options); return time;
@Override protected Span _nextSpan(PointerType pointer) { int direction = (pointer == Pointer.PointerType.FUTURE) ? 1 : -1; if (_secondStart == null) { _secondStart = Time.cloneAndAdd(getNow(), Calendar.SECOND, direction); } else { _secondStart.add(Calendar.SECOND, direction); } return new Span(_secondStart, Calendar.SECOND, 1); }
@Override public void process(JCas jCas) throws AnalysisEngineProcessException { Type t = jCas.getTypeSystem().getType(dateType); if (t != null) { AnnotationIndex<Annotation> annoIndex = jCas.getAnnotationIndex(); FSIterator<Annotation> iter = annoIndex.iterator(); while (iter.hasNext()) { Annotation anno = iter.next(); try { Span span = Chronic.parse(anno.getCoveredText()); if (span != null && span.getBeginCalendar() != null) { Date date = new Date(jCas); date.setBegin(anno.getBegin()); date.setEnd(anno.getEnd()); date.setDate(tlDateFormat.get().format( span.getBeginCalendar().getTime())); date.addToIndexes(); } } catch (Exception e) { if (log.isDebugEnabled()) log.debug( "chronic failed on: " + anno.getCoveredText(), e); } } } }
public long parseDateShorthand(String d) { Calendar now = Calendar.getInstance(); long l=now.getTimeInMillis(); d=d.trim(); if (d.compareToIgnoreCase("now")!=0) { Options options= new Options(false); options.setCompatibilityMode(true); options.setNow(now); try { Span span = Chronic.parse(d, options); l = span.getBegin()*1000; } catch (Exception e) { // exception when parsing log.error("parse error for: "+d); } } /* * debug */ /* SimpleDateFormat sf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); Date ld=new Date(l); log.error("Convert:"+d+" to "+Long.toString(l)+" - "+sf.format(ld)+ "-"+ld.getTime()); */ return l; }