mirror of
https://github.com/yacy/yacy_search_server.git
synced 2025-02-08 07:38:41 -05:00
818 lines
44 KiB
Java
818 lines
44 KiB
Java
/**
|
||
* DateDetection
|
||
* Copyright 2014 by Michael Peter Christen
|
||
* First released 12.12.2014 at https://yacy.net
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2.1 of the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public License
|
||
* along with this program in the file lgpl21.txt
|
||
* If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
package net.yacy.document;
|
||
|
||
import java.time.DayOfWeek;
|
||
import java.time.LocalDate;
|
||
import java.time.LocalTime;
|
||
import java.time.ZoneOffset;
|
||
import java.time.ZonedDateTime;
|
||
import java.time.format.DateTimeFormatter;
|
||
import java.time.temporal.TemporalAdjuster;
|
||
import java.time.temporal.TemporalAdjusters;
|
||
import java.util.ArrayList;
|
||
import java.util.Calendar;
|
||
import java.util.Collections;
|
||
import java.util.Date;
|
||
import java.util.GregorianCalendar;
|
||
import java.util.HashMap;
|
||
import java.util.HashSet;
|
||
import java.util.LinkedHashMap;
|
||
import java.util.LinkedHashSet;
|
||
import java.util.Locale;
|
||
import java.util.Map;
|
||
import java.util.Set;
|
||
import java.util.TimeZone;
|
||
import java.util.TreeMap;
|
||
import java.util.regex.Matcher;
|
||
import java.util.regex.Pattern;
|
||
|
||
import com.ibm.icu.util.DateRule;
|
||
import com.ibm.icu.util.EasterHoliday;
|
||
import com.ibm.icu.util.SimpleDateRule;
|
||
|
||
import net.yacy.cora.date.AbstractFormatter;
|
||
import net.yacy.cora.date.GenericFormatter;
|
||
|
||
/**
|
||
* The purpose of this class exceeds the demands on simple date parsing using a SimpleDateFormat
|
||
* because it tries to
|
||
* - discover where in a text a date is given
|
||
* - recognize human ways of date description and get it into a context, like 'next friday'
|
||
* - enrich partially given dates, i.e. when the year is omitted
|
||
* - understand different languages
|
||
*/
|
||
public class DateDetection {
|
||
|
||
private static final TimeZone UTC_TIMEZONE = TimeZone.getTimeZone("UTC");
|
||
private static final String CONPATT = "uuuu/MM/dd";
|
||
|
||
private static final DateTimeFormatter CONFORM = DateTimeFormatter.ofPattern(CONPATT).withLocale(Locale.US)
|
||
.withZone(ZoneOffset.UTC);
|
||
private static final LinkedHashMap<Language, String[]> Weekdays = new LinkedHashMap<>();
|
||
private static final LinkedHashMap<Language, String[]> Months = new LinkedHashMap<>();
|
||
private static final int[] MaxDaysInMonth = new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
|
||
|
||
// to assign names for days and months, we must know what language is used to express that time
|
||
public static enum Language {
|
||
GERMAN, ENGLISH, FRENCH, SPANISH, ITALIAN, PORTUGUESE;
|
||
}
|
||
|
||
static {
|
||
// all names must be lowercase because compared strings are made to lowercase as well
|
||
Weekdays.put(Language.GERMAN, new String[]{"montag", "dienstag", "mittwoch", "donnerstag", "freitag", "samstag" /*oder: "sonnabend"*/, "sonntag"});
|
||
Weekdays.put(Language.ENGLISH, new String[]{"monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"});
|
||
Weekdays.put(Language.FRENCH, new String[]{"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"});
|
||
Weekdays.put(Language.SPANISH, new String[]{"lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"});
|
||
Weekdays.put(Language.ITALIAN, new String[]{"lunedì", "martedì", "mercoledì", "giovedì", "venerdì", "sabato", "domenica"});
|
||
Months.put(Language.GERMAN, new String[]{"januar", "februar", "märz", "april", "mai", "juni", "juli", "august", "september", "oktober", "november", "dezember"});
|
||
Months.put(Language.ENGLISH, new String[]{"january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"});
|
||
Months.put(Language.FRENCH, new String[]{"janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"});
|
||
Months.put(Language.SPANISH, new String[]{"enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"});
|
||
Months.put(Language.ITALIAN, new String[]{"gennaio", "febbraio", "marzo", "aprile", "maggio", "giugno", "luglio", "agosto", "settembre", "ottobre", "novembre", "dicembre"});
|
||
Months.put(Language.PORTUGUESE,new String[]{"janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"});
|
||
|
||
}
|
||
|
||
// RFC 822 day and month specification as a norm for date formats. This is needed to reconstruct the actual date later
|
||
public static enum Weekday {
|
||
Mon(Weekdays, 0),
|
||
Tue(Weekdays, 1),
|
||
Wed(Weekdays, 2),
|
||
Thu(Weekdays, 3),
|
||
Fri(Weekdays, 4),
|
||
Sat(Weekdays, 5),
|
||
Sun(Weekdays, 6);
|
||
|
||
private final Map<String, Language> inLanguages; // a map from the word to the language
|
||
public final int offset; // the day offset in the week, monday = 0
|
||
private Weekday(final LinkedHashMap<Language, String[]> weekdayMap, final int offset) {
|
||
this.inLanguages = new HashMap<>();
|
||
this.offset = offset;
|
||
for (Map.Entry<Language, String[]> entry: weekdayMap.entrySet()) {
|
||
this.inLanguages.put(entry.getValue()[offset], entry.getKey());
|
||
}
|
||
}
|
||
}
|
||
|
||
public static enum Month {
|
||
Jan( 1), Feb( 2), Mar( 3), Apr( 4), May( 5), Jun( 6),
|
||
Jul( 7), Aug( 8), Sep( 9), Oct(10), Nov(11), Dec(12);
|
||
//private final Map<String, Language> inLanguages;
|
||
private final int count;
|
||
private Month(final int count) {
|
||
this.count = count;
|
||
}
|
||
}
|
||
|
||
public static enum EntityType {
|
||
YEAR(new LinkedHashMap<Language, String[]>()),
|
||
MONTH(Months),
|
||
DAY(new LinkedHashMap<Language, String[]>()),
|
||
WEEKDAYS(Weekdays);
|
||
LinkedHashMap<Language, String[]> languageTerms;
|
||
EntityType(LinkedHashMap<Language, String[]> languageTerms) {
|
||
this.languageTerms = languageTerms;
|
||
}
|
||
}
|
||
|
||
private final static int CURRENT_YEAR = LocalDate.now().getYear(); // we need that to parse dates without given years, see the ShortStyle class
|
||
|
||
private final static String BODNCG = "(?:\\s|^)"; // begin of date non-capturing group
|
||
private final static String EODNCG = "(?:[).:;! ]|$)"; // end of date non-capturing group
|
||
private final static String SEPARATORNCG = "(?:/|-| - |\\.\\s|,\\s|\\.|,|\\s)"; // separator non-capturing group
|
||
private final static String DAYCAPTURE = "(\\d{1,2})";
|
||
private final static String YEARCAPTURE = "(\\d{2}|\\d{4})";
|
||
private final static String MONTHCAPTURE = "(\\p{L}{3,}|\\d{1,2})";
|
||
|
||
public static class HolidayMap extends TreeMap<String, Date[]>{
|
||
private static final long serialVersionUID = 1L;
|
||
public HolidayMap() {
|
||
super(String.CASE_INSENSITIVE_ORDER);
|
||
}
|
||
}
|
||
|
||
public static HolidayMap Holidays = new HolidayMap();
|
||
public static Map<Pattern, Date[]> HolidayPattern = new HashMap<>();
|
||
|
||
static {
|
||
Holidays.putAll(getHolidays(CURRENT_YEAR));
|
||
|
||
for (Map.Entry<String, Date[]> holiday: Holidays.entrySet()) {
|
||
HolidayPattern.put(Pattern.compile(BODNCG + holiday.getKey() + EODNCG), holiday.getValue());
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param currentYear
|
||
* the current year reference to use
|
||
* @return a new mapping from holiday names to arrays of
|
||
* three or four holiday dates starting from currentYear - 1. Each date time is 00:00:00 on UTC+00:00 time zone.
|
||
*/
|
||
public static HolidayMap getHolidays(final int currentYear) {
|
||
final HolidayMap result = new HolidayMap();
|
||
|
||
/* Date rules from icu4j library used here (SimpleDateRule and EasterRule) use internally the default time zone and this can not be modified (up to icu4j 60.1) */
|
||
final TimeZone dateRulesTimeZone = TimeZone.getDefault();
|
||
// German
|
||
result.put("Neujahr", sameDayEveryYear(Calendar.JANUARY, 1, currentYear));
|
||
result.put("Heilige Drei Könige", sameDayEveryYear(Calendar.JANUARY, 6, currentYear));
|
||
result.put("Valentinstag", sameDayEveryYear(Calendar.FEBRUARY, 14, currentYear));
|
||
|
||
/* Fat Thursday : Thursday (6 days) before Ash Wednesday (52 days before Easter Sunday) */
|
||
result.put("Weiberfastnacht", holiDayEventRule(new EasterHoliday(-52, "Weiberfastnacht").getRule(), currentYear, dateRulesTimeZone)); // new Date[]{CONFORM.parse("2014/02/27"), CONFORM.parse("2015/02/12"), CONFORM.parse("2016/02/04")});
|
||
result.put("Weiberfasching", result.get("Weiberfastnacht"));
|
||
|
||
/* Rose Monday : Monday before Ash Wednesday (48 days before Easter Sunday) */
|
||
result.put("Rosenmontag", holiDayEventRule(new EasterHoliday(-48, "Rosenmontag").getRule(), currentYear, dateRulesTimeZone)); // new Date[]{CONFORM.parse("2014/03/03"), CONFORM.parse("2015/03/16"), CONFORM.parse("2016/02/08")});
|
||
result.put("Faschingsdienstag", holiDayEventRule(EasterHoliday.SHROVE_TUESDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/03/04"), CONFORM.parse("2015/03/17"), CONFORM.parse("2016/02/09")});
|
||
result.put("Fastnacht", result.get("Faschingsdienstag")); // new Date[]{CONFORM.parse("2014/03/04"), CONFORM.parse("2015/03/17"), CONFORM.parse("2016/02/09")});
|
||
result.put("Aschermittwoch", holiDayEventRule(EasterHoliday.ASH_WEDNESDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/03/05"), CONFORM.parse("2015/03/18"), CONFORM.parse("2016/02/10")});
|
||
result.put("Palmsonntag", holiDayEventRule(EasterHoliday.PALM_SUNDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/04/13"), CONFORM.parse("2015/03/29"), CONFORM.parse("2016/04/20")});
|
||
result.put("Gründonnerstag", holiDayEventRule(EasterHoliday.MAUNDY_THURSDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/04/17"), CONFORM.parse("2015/04/02"), CONFORM.parse("2016/04/24")});
|
||
result.put("Karfreitag", holiDayEventRule(EasterHoliday.GOOD_FRIDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/04/18"), CONFORM.parse("2015/04/03"), CONFORM.parse("2016/04/25")});
|
||
|
||
/* Holy Saturday (also called Easter Eve, Black Saturday) : one day before Easter Sunday */
|
||
result.put("Karsamstag", holiDayEventRule(new EasterHoliday(-1, "Karsamstag").getRule(), currentYear, dateRulesTimeZone)); // new Date[]{CONFORM.parse("2014/04/19"), CONFORM.parse("2015/04/04"), CONFORM.parse("2016/04/26")});
|
||
result.put("Ostersonntag", holiDayEventRule(EasterHoliday.EASTER_SUNDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/04/20"), CONFORM.parse("2015/04/05"), CONFORM.parse("2016/04/27")});
|
||
result.put("Ostermontag", holiDayEventRule(EasterHoliday.EASTER_MONDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/04/21"), CONFORM.parse("2015/04/06"), CONFORM.parse("2016/04/28")});
|
||
|
||
/* Include both Easter Sunday and Monday */
|
||
result.put("Ostern", getOsternEventRule(currentYear, dateRulesTimeZone));
|
||
result.put("Walpurgisnacht", sameDayEveryYear(Calendar.APRIL, 30, currentYear));
|
||
result.put("Tag der Arbeit", sameDayEveryYear(Calendar.MAY, 1, currentYear));
|
||
|
||
/* Mother's Day : Second sunday of may in Germany */
|
||
final Date[] mothersDays = new Date[3];
|
||
int year = currentYear - 1;
|
||
for (int i = 0; i < 3; i++) {
|
||
final LocalDate firstMay = LocalDate.of(year, java.time.Month.MAY, 1);
|
||
final LocalDate mothersDay = firstMay.with(TemporalAdjusters.firstInMonth(DayOfWeek.SUNDAY)).with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
|
||
mothersDays[i] = toMidnightUTCDate(mothersDay);
|
||
year++;
|
||
}
|
||
result.put("Muttertag", mothersDays);
|
||
result.put("Christi Himmelfahrt", holiDayEventRule(EasterHoliday.ASCENSION.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/05/29"), CONFORM.parse("2015/05/14"), CONFORM.parse("2016/05/05")});
|
||
result.put("Pfingstsonntag", holiDayEventRule(EasterHoliday.WHIT_SUNDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/06/08"), CONFORM.parse("2015/05/24"), CONFORM.parse("2016/05/15")});
|
||
result.put("Pfingstmontag", holiDayEventRule(EasterHoliday.WHIT_MONDAY.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/06/09"), CONFORM.parse("2015/05/25"), CONFORM.parse("2016/05/16")});
|
||
result.put("Fronleichnam", holiDayEventRule(EasterHoliday.CORPUS_CHRISTI.getRule(), currentYear, dateRulesTimeZone));// new Date[]{CONFORM.parse("2014/06/19"), CONFORM.parse("2015/06/04"), CONFORM.parse("2016/05/25")});
|
||
result.put("Mariä Himmelfahrt", sameDayEveryYear(Calendar.AUGUST, 15, currentYear));
|
||
result.put("Tag der Deutschen Einheit", sameDayEveryYear(Calendar.OCTOBER, 3, currentYear));
|
||
result.put("Reformationstag", sameDayEveryYear(Calendar.OCTOBER, 31, currentYear));
|
||
result.put("Allerheiligen", sameDayEveryYear(Calendar.NOVEMBER, 1, currentYear));
|
||
result.put("Allerseelen", sameDayEveryYear(Calendar.NOVEMBER, 2, currentYear));
|
||
result.put("Martinstag", sameDayEveryYear(Calendar.NOVEMBER, 11, currentYear));
|
||
result.put("St. Martin", result.get("Martinstag"));
|
||
result.put("Buß- und Bettag", holiDayEventRule(new SimpleDateRule(Calendar.NOVEMBER, 22, Calendar.WEDNESDAY, true), currentYear, dateRulesTimeZone)); // new Date[]{CONFORM.parse("2014/11/19"), CONFORM.parse("2015/11/18"), CONFORM.parse("2016/11/16")});
|
||
result.put("Nikolaus", sameDayEveryYear(Calendar.DECEMBER, 6, currentYear));
|
||
result.put("Heiligabend", sameDayEveryYear(Calendar.DECEMBER, 24, currentYear));
|
||
result.put("1. Weihnachtsfeiertag", sameDayEveryYear(Calendar.DECEMBER, 25, currentYear));
|
||
result.put("2. Weihnachtsfeiertag", sameDayEveryYear(Calendar.DECEMBER, 26, currentYear));
|
||
|
||
/* Advent : four Sundays before Chritsmas */
|
||
final Date[] advents1 = new Date[3], advents2 = new Date[3], advents3 = new Date[3], advents4 = new Date[3],
|
||
volkstrauertagen = new Date[3], sundaysOfTheDead = new Date[3];
|
||
|
||
year = currentYear - 1;
|
||
final TemporalAdjuster prevSunday = TemporalAdjusters.previous(DayOfWeek.SUNDAY);
|
||
for (int i = 0; i < 3; i++) {
|
||
final LocalDate christmas = LocalDate.of(year, java.time.Month.DECEMBER, 25);
|
||
final LocalDate advent4 = christmas.with(prevSunday);
|
||
final LocalDate advent3 = advent4.with(prevSunday);
|
||
final LocalDate advent2 = advent3.with(prevSunday);
|
||
final LocalDate advent1 = advent2.with(prevSunday);
|
||
final LocalDate sundayOfTheDead = advent1.with(prevSunday);
|
||
final LocalDate volkstrauertag = sundayOfTheDead.with(prevSunday);
|
||
advents4[i] = toMidnightUTCDate(advent4);
|
||
advents3[i] = toMidnightUTCDate(advent3);
|
||
advents2[i] = toMidnightUTCDate(advent2);
|
||
advents1[i] = toMidnightUTCDate(advent1);
|
||
sundaysOfTheDead[i] = toMidnightUTCDate(sundayOfTheDead);
|
||
volkstrauertagen[i] = toMidnightUTCDate(volkstrauertag);
|
||
year++;
|
||
}
|
||
|
||
result.put("1. Advent", advents1);
|
||
result.put("2. Advent", advents2);
|
||
result.put("3. Advent", advents3);
|
||
result.put("4. Advent", advents4);
|
||
|
||
/* Sunday of the Dead (also called Eternity Sunday) : last Sunday before Advent */
|
||
result.put("Totensonntag", sundaysOfTheDead);
|
||
|
||
/* "people's day of mourning" : two Sundays before Advent */
|
||
result.put("Volkstrauertag", volkstrauertagen);
|
||
|
||
result.put("Silvester", sameDayEveryYear(Calendar.DECEMBER, 31, currentYear));
|
||
|
||
// English
|
||
result.put("Eastern", result.get("Ostern"));
|
||
result.put("New Year's Day", result.get("Neujahr"));
|
||
result.put("Epiphany", result.get("Heilige Drei Könige"));
|
||
result.put("Valentine's Day", result.get("Valentinstag"));
|
||
result.put("Orthodox Christmas", sameDayEveryYear(Calendar.JANUARY, 7, currentYear));
|
||
result.put("St. Patrick's Day", sameDayEveryYear(Calendar.MARCH, 17, currentYear));
|
||
result.put("April Fools' Day", sameDayEveryYear(Calendar.APRIL, 1, currentYear));
|
||
result.put("Independence Day", sameDayEveryYear(Calendar.JULY, 4, currentYear));
|
||
result.put("Halloween", result.get("Reformationstag"));
|
||
result.put("Thanksgiving", holiDayEventRule(new SimpleDateRule(Calendar.NOVEMBER, 22, Calendar.THURSDAY, true), currentYear, dateRulesTimeZone));
|
||
result.put("Immaculate Conception of the Virgin Mary", sameDayEveryYear(Calendar.DECEMBER, 8, currentYear));
|
||
result.put("Christmas Eve", result.get("Heiligabend"));
|
||
result.put("Christmas Day", result.get("1. Weihnachtsfeiertag"));
|
||
result.put("Boxing Day", result.get("2. Weihnachtsfeiertag"));
|
||
result.put("New Year's Eve", result.get("Silvester"));
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* Convert a date to an old style java.util.Date instance with time set at
|
||
* midnight on UTC time zone.
|
||
*
|
||
* @param localDate
|
||
* a simple date with year month and day without time zone
|
||
* @return a java.util.Date instance or null when localDate is null
|
||
*/
|
||
public static Date toMidnightUTCDate(final LocalDate localDate) {
|
||
if (localDate == null) {
|
||
return null;
|
||
}
|
||
return Date.from(ZonedDateTime.of(localDate, LocalTime.MIDNIGHT, UTC_TIMEZONE.toZoneId()).toInstant());
|
||
}
|
||
|
||
/**
|
||
* @param month value of month (Calendar.month is 0 based)
|
||
* @param day
|
||
* @param currentYear the current year reference to use
|
||
* @return four years of same date starting in last year (currentYear - 1)
|
||
*/
|
||
private static Date[] sameDayEveryYear(final int month, final int day, final int currentYear) {
|
||
final Date[] r = new Date[4];
|
||
final Calendar cal = new GregorianCalendar(UTC_TIMEZONE);
|
||
cal.clear();
|
||
cal.set(currentYear - 1, month, day); // set start in previous year
|
||
r[0] = cal.getTime();
|
||
for (int y = 1; y < 4; y++) {
|
||
cal.add(Calendar.YEAR, 1);
|
||
r[y] = cal.getTime();
|
||
}
|
||
return r;
|
||
}
|
||
|
||
/**
|
||
* @param holidayrule a date rule to calculate a holiday from a reference date
|
||
* @param ruleTimeZone the time zone of calendar used in the holiday rule
|
||
* @param currentYear the current year reference to use
|
||
* @return 3 years of same holiday starting in last year (currentYear - 1)
|
||
*/
|
||
private static Date[] holiDayEventRule(final DateRule holidayrule, final int currentYear, final TimeZone ruleTimeZone) {
|
||
final Date[] r = new Date[3];
|
||
final Calendar january1Calendar = new GregorianCalendar(ruleTimeZone);
|
||
/* Clear all fields to get a 00:00:00:000 time part */
|
||
january1Calendar.clear();
|
||
|
||
/* Calendar using UTC time zone to produce date results */
|
||
final Calendar utcCalendar = new GregorianCalendar(UTC_TIMEZONE);
|
||
|
||
/* Calendar using the same time zone as in the holidayrule to extract year,month, and day fields */
|
||
final Calendar ruleCalendar = new GregorianCalendar(ruleTimeZone);
|
||
|
||
int year = currentYear -1; // set previous year as start year
|
||
for (int y = 0; y < 3; y++) {
|
||
january1Calendar.set(year, Calendar.JANUARY, 1);
|
||
Date holiday = holidayrule.firstAfter(january1Calendar.getTime());
|
||
ruleCalendar.setTime(holiday);
|
||
utcCalendar.set(ruleCalendar.get(Calendar.YEAR), ruleCalendar.get(Calendar.MONTH),
|
||
ruleCalendar.get(Calendar.DAY_OF_MONTH));
|
||
r[y] = utcCalendar.getTime();
|
||
year++;
|
||
}
|
||
return r;
|
||
}
|
||
|
||
/**
|
||
* @param currentYear the current year reference to use
|
||
* @param ruleTimeZone the time zone of calendar used in the holiday rule
|
||
* @return Easter sunday and monday dates on three years starting from last year
|
||
*/
|
||
private static Date[] getOsternEventRule(final int currentYear, final TimeZone ruleTimeZone) {
|
||
ArrayList<Date> osternDates = new ArrayList<>();
|
||
Collections.addAll(osternDates, holiDayEventRule(EasterHoliday.EASTER_SUNDAY.getRule(), currentYear, ruleTimeZone));
|
||
Collections.addAll(osternDates, holiDayEventRule(EasterHoliday.EASTER_MONDAY.getRule(), currentYear, ruleTimeZone));
|
||
return osternDates.toArray(new Date[osternDates.size()]);
|
||
}
|
||
|
||
/**
|
||
* The language recognition subclass understands date description parts in different languages.
|
||
* It can also be used to identify the language of a text, if that text uses words from a date vocabulary.
|
||
*/
|
||
public static class LanguageRecognition {
|
||
|
||
private final Pattern weekdayMatch, monthMatch;
|
||
private final Set<Language> usedInLanguages;
|
||
private final Map<String, Integer> weekdayIndex, monthIndex, monthIndexAbbrev;
|
||
|
||
public LanguageRecognition(Language[] languages) {
|
||
this.usedInLanguages = new HashSet<Language>();
|
||
// prepare a month index for the languages that this notion supports
|
||
this.weekdayIndex = new HashMap<>();
|
||
this.monthIndex = new HashMap<>();
|
||
this.monthIndexAbbrev = new HashMap<>();
|
||
StringBuilder weekdayMatchString = new StringBuilder();
|
||
StringBuilder monthMatchString = new StringBuilder();
|
||
for (Language language: languages) {
|
||
this.usedInLanguages.add(language);
|
||
|
||
String[] weekdays = Weekdays.get(language);
|
||
if (weekdays != null) {
|
||
assert weekdays.length == 7;
|
||
for (int i = 0; i < 7; i++) {
|
||
this.weekdayIndex.put(weekdays[i], i);
|
||
weekdayMatchString.append("|(?:").append(BODNCG).append(weekdays[i]).append(SEPARATORNCG).append(EODNCG).append(')');
|
||
}
|
||
}
|
||
|
||
String[] months = Months.get(language);
|
||
if (months != null) {
|
||
assert months.length == 12;
|
||
for (int i = 0; i < 12; i++) {
|
||
monthIndex.put(months[i], i + 1);
|
||
monthMatchString.append("|(?:").append(BODNCG).append(months[i]).append(SEPARATORNCG).append(EODNCG).append(')');
|
||
String abbrev = months[i].substring(0, 3);
|
||
if (monthIndexAbbrev.containsKey(abbrev) && monthIndexAbbrev.get(abbrev).intValue() != i + 1)
|
||
monthIndexAbbrev.put(abbrev, -1); // ambiguous months get a -1
|
||
else
|
||
monthIndexAbbrev.put(abbrev, i + 1);
|
||
}
|
||
}
|
||
}
|
||
this.weekdayMatch = Pattern.compile(weekdayMatchString.length() > 0 ? weekdayMatchString.substring(1) : "");
|
||
this.monthMatch = Pattern.compile(monthMatchString.length() > 0 ? monthMatchString.substring(1) : "");
|
||
}
|
||
|
||
/**
|
||
* this is an expensive check that looks if any of the words from the date expressions (month and weekday expressions)
|
||
* appear in the text. This should only be used to verify a parse result if the result was ambiguous
|
||
* @param text
|
||
* @return true if one of the month and weekday expressions appear in the text
|
||
*/
|
||
public boolean usesLanguageOfNotion(String text) {
|
||
return this.weekdayMatch.matcher(text).matches() || this.monthMatch.matcher(text).matches();
|
||
}
|
||
|
||
/**
|
||
* parse a part of a date
|
||
* @param entity
|
||
* @param object
|
||
* @return a scalar value associated with this date part
|
||
*/
|
||
public int parseEntity(EntityType entity, String object) {
|
||
if (entity == EntityType.YEAR) {
|
||
try {
|
||
int i = Integer.parseInt(object);
|
||
if (i < 100) i += 2000; // yes that makes it possible to parse the years 0-99 and it will be incorrect in the year 2100 when that is abbreviated with 00
|
||
if (i > CURRENT_YEAR + 10) return -1; // there are very rarely dates in the future that far
|
||
return i;
|
||
} catch (NumberFormatException e) {
|
||
return -1;
|
||
}
|
||
}
|
||
if (entity == EntityType.MONTH) {
|
||
try {
|
||
int i = Integer.parseInt(object);
|
||
if (i >= 1 && i <= 12) return i;
|
||
return -1; // no reason to try in a different way, its just a wrong number
|
||
} catch (NumberFormatException e) {
|
||
// this may be the name of a month
|
||
if (object.length() == 3) {
|
||
// try RFC 822 names
|
||
object = object.substring(0, 1).toUpperCase() + object.substring(1).toLowerCase();
|
||
try {
|
||
Month m = Month.valueOf(object);
|
||
return m.count;
|
||
} catch (IllegalArgumentException | NoClassDefFoundError ee) {} // just ignore this, that was just a try to shorten things..
|
||
}
|
||
// try the collection of names for each language
|
||
object = object.toLowerCase(); // the stored month names are all lowercase
|
||
Integer i = this.monthIndex.get(object);
|
||
if (i != null) return i.intValue();
|
||
// try an abbreviation
|
||
if (object.length() == 3) {
|
||
i = this.monthIndexAbbrev.get(object.substring(0, 3));
|
||
if (i != null) return i.intValue(); // may also be -1!
|
||
}
|
||
return -1;
|
||
}
|
||
}
|
||
if (entity == EntityType.DAY) {
|
||
try {
|
||
int i = Integer.parseInt(object);
|
||
if (i < 1 || i > 31) return -1;
|
||
return i;
|
||
} catch (NumberFormatException e) {
|
||
return -1;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
}
|
||
|
||
private final static LanguageRecognition ENGLISH_LANGUAGE = new LanguageRecognition(new Language[]{Language.ENGLISH});
|
||
private final static LanguageRecognition GERMAN_LANGUAGE = new LanguageRecognition(new Language[]{Language.GERMAN});
|
||
private final static LanguageRecognition FRENCH_LANGUAGE = new LanguageRecognition(new Language[]{Language.FRENCH});
|
||
private final static LanguageRecognition ENGLISH_GERMAN_LANGUAGE = new LanguageRecognition(new Language[]{Language.GERMAN, Language.ENGLISH});
|
||
private final static LanguageRecognition ENGLISH_GERMAN_FRENCH_SPANISH_ITALIAN_LANGUAGE = new LanguageRecognition(new Language[]{Language.GERMAN, Language.ENGLISH, Language.FRENCH, Language.SPANISH, Language.ITALIAN, Language.PORTUGUESE});
|
||
|
||
public static interface StyleParser {
|
||
/**
|
||
* get all dates in the text
|
||
* @param text
|
||
* @return a set of dates, ordered by occurrence.
|
||
*/
|
||
public LinkedHashSet<Date> parse(String text);
|
||
}
|
||
|
||
/**
|
||
* Regular expressions for various types of date writings.
|
||
* Uses terminology and data taken from:
|
||
* http://en.wikipedia.org/wiki/Date_format_by_country
|
||
*/
|
||
public static enum EndianStyle implements StyleParser {
|
||
YMD(EntityType.YEAR, EntityType.MONTH, EntityType.DAY, // Big-endian (year, month, day), e.g. 1996-04-22
|
||
ENGLISH_GERMAN_LANGUAGE, // GERMAN: 'official standard date format', ENGLISH: used in UK
|
||
BODNCG + YEARCAPTURE + SEPARATORNCG + MONTHCAPTURE + SEPARATORNCG + DAYCAPTURE + EODNCG
|
||
),
|
||
DMY(EntityType.DAY, EntityType.MONTH, EntityType.YEAR, // Little-endian (day, month, year), e.g. 22.04.96 or 22/04/96 or 22 April 1996
|
||
ENGLISH_GERMAN_FRENCH_SPANISH_ITALIAN_LANGUAGE, // GERMAN: traditional, ENGLISH: used in UK
|
||
BODNCG + DAYCAPTURE + SEPARATORNCG + MONTHCAPTURE + SEPARATORNCG + YEARCAPTURE + EODNCG
|
||
),
|
||
MDY(EntityType.MONTH, EntityType.DAY, EntityType.YEAR, // Middle-endian (month, day, year), e.g. 04/22/96 or April 22, 1996
|
||
ENGLISH_LANGUAGE, // ENGLISH: used in USA
|
||
BODNCG + MONTHCAPTURE + SEPARATORNCG + DAYCAPTURE + SEPARATORNCG + YEARCAPTURE + EODNCG
|
||
);
|
||
|
||
private final Pattern pattern;
|
||
private final EntityType firstEntity, secondEntity, thirdEntity;
|
||
public final LanguageRecognition languageParser;
|
||
EndianStyle(EntityType firstEntity, EntityType secondEntity, EntityType thirdEntity, LanguageRecognition languageParser, String patternString) {
|
||
this.firstEntity = firstEntity;
|
||
this.secondEntity = secondEntity;
|
||
this.thirdEntity = thirdEntity;
|
||
this.pattern = Pattern.compile(patternString);
|
||
this.languageParser = languageParser;
|
||
}
|
||
|
||
/**
|
||
* get all dates in the text
|
||
* @param text
|
||
* @return a set of dates, ordered by occurrence.
|
||
*/
|
||
@Override
|
||
public LinkedHashSet<Date> parse(final String text) {
|
||
LinkedHashSet<Date> dates = new LinkedHashSet<>();
|
||
Matcher matcher = this.pattern.matcher(text);
|
||
while (matcher.find()) {
|
||
if (!(matcher.groupCount() == 3)) continue;
|
||
String entity1 = matcher.group(1); if (entity1 == null) continue;
|
||
String entity2 = matcher.group(2); if (entity2 == null) continue;
|
||
String entity3 = matcher.group(3); if (entity3 == null) continue;
|
||
//System.out.println("FRAGMENTS: entity1=" + entity1 + ", entity2=" + entity2 + ", entity3=" + entity3); // DEBUG
|
||
int i1 = languageParser.parseEntity(this.firstEntity, entity1);
|
||
if (i1 < 0) continue;
|
||
int i2 = languageParser.parseEntity(this.secondEntity, entity2);
|
||
if (i2 < 0) continue;
|
||
int i3 = languageParser.parseEntity(this.thirdEntity, entity3);
|
||
if (i3 < 0) continue;
|
||
int day = this.firstEntity == EntityType.DAY ? i1 : this.secondEntity == EntityType.DAY ? i2 : i3;
|
||
int month = this.firstEntity == EntityType.MONTH ? i1 : this.secondEntity == EntityType.MONTH ? i2 : i3;
|
||
if (day > MaxDaysInMonth[month - 1]) continue; // validity check of the day number
|
||
int year = this.firstEntity == EntityType.YEAR ? i1 : this.secondEntity == EntityType.YEAR ? i2 : i3;
|
||
final Date parsed = parseDateSafely(
|
||
year + "/" + (month < 10 ? "0" : "") + month + "/" + (day < 10 ? "0" : "") + day, CONFORM);
|
||
if(parsed != null) {
|
||
dates.add(parsed);
|
||
}
|
||
if (dates.size() > 100) {dates.clear(); break;} // that does not make sense
|
||
}
|
||
return dates;
|
||
}
|
||
|
||
}
|
||
|
||
/**
|
||
* Safely parse the given string to an instant using the given formatter. Return
|
||
* null when the format can not be applied to the given string or when any
|
||
* parsing error occurred.
|
||
*
|
||
* @param str
|
||
* the string to parse
|
||
* @param formatter
|
||
* the formatter to use
|
||
* @return an Instant instance or null
|
||
*/
|
||
protected static Date parseDateSafely(final String str, final DateTimeFormatter formatter) {
|
||
Date res = null;
|
||
if (str != null && !str.isEmpty()) {
|
||
try {
|
||
if (formatter != null) {
|
||
res = Date.from(LocalDate.parse(str, formatter).atStartOfDay().toInstant(ZoneOffset.UTC));
|
||
}
|
||
} catch (final RuntimeException ignored) {
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
public static enum ShortStyle implements StyleParser {
|
||
MD_ENGLISH(EntityType.MONTH, EntityType.DAY, // Big-endian (month, day), e.g. "from october 1st to september 13th"
|
||
ENGLISH_LANGUAGE,
|
||
BODNCG + "on " + MONTHCAPTURE + SEPARATORNCG + DAYCAPTURE + EODNCG
|
||
),
|
||
DM_GERMAN(EntityType.DAY, EntityType.MONTH, // Little-endian (day, month), e.g. "am 1. April"
|
||
GERMAN_LANGUAGE,
|
||
BODNCG + "am " + DAYCAPTURE + SEPARATORNCG + MONTHCAPTURE + EODNCG
|
||
),
|
||
DM_FRENCH(EntityType.DAY, EntityType.MONTH, // Little-endian (day, month), e.g. "le 29 Septembre,"
|
||
FRENCH_LANGUAGE,
|
||
BODNCG + "le " + DAYCAPTURE + " " + MONTHCAPTURE + EODNCG
|
||
),
|
||
DM_ITALIAN(EntityType.DAY, EntityType.MONTH, // Little-endian (day, month), e.g. "il 29 settembre,"
|
||
FRENCH_LANGUAGE,
|
||
BODNCG + "il " + DAYCAPTURE + " " + MONTHCAPTURE + EODNCG
|
||
),
|
||
DM_SPANISH(EntityType.DAY, EntityType.MONTH, // Little-endian (day, month), e.g. "el 29 de septiembre,"
|
||
FRENCH_LANGUAGE,
|
||
BODNCG + "el " + DAYCAPTURE + " de " + MONTHCAPTURE + EODNCG
|
||
);
|
||
public final Pattern pattern;
|
||
private final EntityType firstEntity, secondEntity;
|
||
public final LanguageRecognition languageParser;
|
||
ShortStyle(EntityType firstEntity, EntityType secondEntity, LanguageRecognition languageParser, String patternString) {
|
||
this.firstEntity = firstEntity;
|
||
this.secondEntity = secondEntity;
|
||
this.pattern = Pattern.compile(patternString);
|
||
this.languageParser = languageParser;
|
||
}
|
||
|
||
/**
|
||
* get all dates in the text
|
||
* @param text
|
||
* @return a set of dates, ordered by occurrence.
|
||
*/
|
||
@Override
|
||
public LinkedHashSet<Date> parse(final String text) {
|
||
LinkedHashSet<Date> dates = new LinkedHashSet<>();
|
||
Matcher matcher = this.pattern.matcher(text);
|
||
//ConcurrentLog.info("DateDetection", "applying matcher: " + matcher.toString());
|
||
while (matcher.find()) {
|
||
if (!(matcher.groupCount() == 2)) continue;
|
||
String entity1 = matcher.group(1); if (entity1 == null) continue;
|
||
String entity2 = matcher.group(2); if (entity2 == null) continue;
|
||
//System.out.println("FRAGMENTS: entity1=" + entity1 + ", entity2=" + entity2 + ", entity3=" + entity3); // DEBUG
|
||
int i1 = languageParser.parseEntity(this.firstEntity, entity1);
|
||
if (i1 < 0) continue;
|
||
int i2 = languageParser.parseEntity(this.secondEntity, entity2);
|
||
if (i2 < 0) continue;
|
||
int day = this.firstEntity == EntityType.DAY ? i1 : i2;
|
||
int month = this.firstEntity == EntityType.MONTH ? i1 : i2;
|
||
if (day > MaxDaysInMonth[month - 1]) continue; // validity check of the day number
|
||
int thisyear = CURRENT_YEAR;
|
||
int nextyear = CURRENT_YEAR + 1;
|
||
String datestub = "/" + (month < 10 ? "0" : "") + month + "/" + (day < 10 ? "0" : "") + day;
|
||
|
||
final Date atThisYear = parseDateSafely(thisyear + datestub, CONFORM);
|
||
if(atThisYear != null) {
|
||
dates.add(atThisYear);
|
||
}
|
||
|
||
final Date atNextYear = parseDateSafely(nextyear + datestub, CONFORM);
|
||
if(atNextYear != null) {
|
||
dates.add(atNextYear);
|
||
}
|
||
//dates.add(atThisYear.after(TODAY) ? atThisYear : atNextYear); // we consider these kind of dates as given for the future
|
||
if (dates.size() > 100) {dates.clear(); break;} // that does not make sense
|
||
}
|
||
return dates;
|
||
}
|
||
|
||
}
|
||
|
||
private static final HashMap<String, Long> specialDayOffset = new HashMap<>();
|
||
static {
|
||
specialDayOffset.put("today", 0L); specialDayOffset.put("heute", 0L);
|
||
specialDayOffset.put("tomorrow", AbstractFormatter.dayMillis); specialDayOffset.put("morgen", AbstractFormatter.dayMillis);
|
||
specialDayOffset.put("dayaftertomorrow", 2 * AbstractFormatter.dayMillis); specialDayOffset.put("uebermorgen", 2 * AbstractFormatter.dayMillis);
|
||
specialDayOffset.put("yesterday", -AbstractFormatter.dayMillis); specialDayOffset.put("gestern", -AbstractFormatter.dayMillis);
|
||
}
|
||
|
||
/**
|
||
* get all dates in the text
|
||
* @param text
|
||
* @param timezoneOffset TODO: implement
|
||
* @return a set of dates, ordered by time. first date in the ordered set is the oldest time.
|
||
*/
|
||
public static LinkedHashSet<Date> parse(String text, int timezoneOffset) {
|
||
|
||
LinkedHashSet<Date> dates = parseRawDate(text);
|
||
|
||
for (Map.Entry<Pattern, Date[]> entry: HolidayPattern.entrySet()) {
|
||
if (entry.getKey().matcher(text).find()) {
|
||
for (Date d: entry.getValue()) dates.add(d);
|
||
}
|
||
}
|
||
return dates;
|
||
}
|
||
|
||
/**
|
||
* Parse a line expected to contain one date expression only.
|
||
* This is used by the query parser for query date modifier on:, from: or to:
|
||
*
|
||
* @param text
|
||
* @param timezoneOffset TODO: implement
|
||
* @return determined date or null
|
||
*/
|
||
public static Date parseLine(final String text, final int timezoneOffset) {
|
||
// check standard date formats
|
||
Date d = parseDateSafely(text, CONFORM);
|
||
//if (d == null) try {d = GenericFormatter.FORMAT_SHORT_DAY.parse(text);} catch (ParseException e) {} // did not work well and fired for wrong formats; do not use
|
||
if (d == null) {
|
||
d = parseDateSafely(text, GenericFormatter.FORMAT_RFC1123_SHORT);
|
||
}
|
||
if (d == null) {
|
||
d = parseDateSafely(text, GenericFormatter.FORMAT_ANSIC);
|
||
}
|
||
|
||
if (d == null) {
|
||
// check other date formats
|
||
Set<Date> dd = parseRawDate(text);
|
||
if (dd.size() >= 1) d = dd.iterator().next(); // this returns the oldest/earliest date from the set (as set is typically ordered by date)
|
||
}
|
||
|
||
if (d == null) {
|
||
Long offset;
|
||
if ((offset = specialDayOffset.get(text)) != null) {
|
||
d = new Date((System.currentTimeMillis() / AbstractFormatter.dayMillis) * AbstractFormatter.dayMillis + offset.longValue());
|
||
}
|
||
}
|
||
|
||
if (d == null) {
|
||
// check holidays
|
||
Date[] dd = Holidays.get(text); // as we expect single expression, we can get directly (w/o matcher)
|
||
// TODO: consider user enters expression like "Silvester 2016" or "Eastern/2017" -> needs a special matcher
|
||
if (dd != null) {
|
||
if (dd.length > 1) {
|
||
d = dd[1]; // this is usually date in current year (as array is initialized [year-1, year, year+1, year+2]
|
||
} else {
|
||
d = dd[0];
|
||
}
|
||
}
|
||
}
|
||
return d;
|
||
}
|
||
|
||
private static LinkedHashSet<Date> parseRawDate(String text) {
|
||
// get parse alternatives for different date styles; we consider that one document uses only one style
|
||
LinkedHashSet<Date> DMYDates = EndianStyle.DMY.parse(text);
|
||
ShortStyle[] shortStyleCheck = new ShortStyle[]{ShortStyle.DM_GERMAN, ShortStyle.DM_FRENCH, ShortStyle.DM_ITALIAN, ShortStyle.DM_SPANISH};
|
||
LinkedHashSet<Date> DMDates = new LinkedHashSet<>();
|
||
for (ShortStyle shortStyle: shortStyleCheck) {
|
||
DMDates.addAll(shortStyle.parse(text));
|
||
if (DMDates.size() > 0) break;
|
||
}
|
||
DMYDates.addAll(DMDates);
|
||
|
||
LinkedHashSet<Date> MDYDates = DMYDates.size() == 0 ? EndianStyle.MDY.parse(text) : new LinkedHashSet<Date>(0);
|
||
LinkedHashSet<Date> MDDates = DMYDates.size() == 0 ? ShortStyle.MD_ENGLISH.parse(text) : new LinkedHashSet<Date>(0);
|
||
MDYDates.addAll(MDDates);
|
||
|
||
LinkedHashSet<Date> YMDDates = DMYDates.size() == 0 && MDYDates.size() == 0 ? EndianStyle.YMD.parse(text) : new LinkedHashSet<Date>(0);
|
||
|
||
// if either one of them contains any and the other contain no date, chose that one (we don't want to mix them)
|
||
if (YMDDates.size() > 0 && DMYDates.size() == 0 && MDYDates.size() == 0) return YMDDates;
|
||
if (YMDDates.size() == 0 && DMYDates.size() > 0 && MDYDates.size() == 0) return DMYDates;
|
||
if (YMDDates.size() == 0 && DMYDates.size() == 0 && MDYDates.size() > 0) return MDYDates;
|
||
|
||
// if we have several sets, check if we can detect the language from month or weekday expressions
|
||
// we sort out such sets, which do not contain any of these languages
|
||
boolean usesLanguageOfYMD = YMDDates.size() > 0 ? false : EndianStyle.YMD.languageParser.usesLanguageOfNotion(text);
|
||
boolean usesLanguageOfDMY = DMYDates.size() > 0 ? false : EndianStyle.DMY.languageParser.usesLanguageOfNotion(text);
|
||
boolean usesLanguageOfMDY = MDYDates.size() > 0 ? false : EndianStyle.MDY.languageParser.usesLanguageOfNotion(text);
|
||
|
||
// now check again
|
||
if (usesLanguageOfYMD && !usesLanguageOfDMY && !usesLanguageOfMDY) return YMDDates;
|
||
if (!usesLanguageOfYMD && usesLanguageOfDMY && !usesLanguageOfMDY) return DMYDates;
|
||
if (!usesLanguageOfYMD && !usesLanguageOfDMY && usesLanguageOfMDY) return MDYDates;
|
||
|
||
// if this fails, we return only the DMY format since that has the most chances to be right (it is mostly used)
|
||
// we choose DMYDates even if it is empty to avoid false positives.
|
||
return DMYDates;
|
||
}
|
||
|
||
public static void main(String[] args) {
|
||
String fill = ""; for (int i = 0; i < 1000; i++) fill += 'x';
|
||
String[] test = new String[]{
|
||
"\n laden die Stadtwerke \n X am Rosenmontag und am \n Faschingsdienstag zur Disko auf die \n",
|
||
"kein Datum im Text",
|
||
" Fastnacht am 4. März noch",
|
||
" Fastnacht am 4. April noch",
|
||
"heute 12. Dezember 2014. ",
|
||
"heute 12. Dezember 2014",
|
||
"12. Dezember 2014. ",
|
||
"heute 12. Dezember 2014 ",
|
||
"heute 12. Dezember 2014. ",
|
||
"Donnerstag, 18. Dezember 2014 xyz",
|
||
"Donnerstag, 18 Dezember 2014 xyz",
|
||
"Donnerstag, 18.Dezember 2014 xyz",
|
||
"Montag, 8. Dezember 2014 xyz",
|
||
"Montag, 8.Dezember 2014 xyz",
|
||
"Donnerstag, 18.12.2014 xyz",
|
||
"Montag, 8.12.2014 xyz",
|
||
"Donnerstag, 18.12.14 xyz",
|
||
"Montag, 8.12.14 xyz",
|
||
"Mitglied seit: 13. Januar 2007 xyz",
|
||
"Im Dezember 2014 xyz",
|
||
"11.12.2014",
|
||
"11. September 2001",
|
||
"12.12.2014 08:43",
|
||
"immer am 1. Dezember abends",
|
||
"immer am 31. Dezember abends",
|
||
"immer am 31. dezember abends",
|
||
"on october 20 every year",
|
||
" on october 20 every year",
|
||
"on September 29,",
|
||
"am Karfreitag um 15:00 Uhr",
|
||
"11 fevereiro 2001", // portuguese
|
||
"12. fevereiro 2002", // portuguese
|
||
"13 de fevereiro 2003", // portuguese
|
||
"Fevereiro 14, 2004" // portuguese
|
||
};
|
||
long t = System.currentTimeMillis();
|
||
for (String s: test) {
|
||
String parsed = parse(fill + " " + s + " " + fill, 0).toString();
|
||
System.out.println("SOURCE: " + s);
|
||
System.out.println("DATE : " + parsed);
|
||
System.out.println();
|
||
}
|
||
System.out.println("Runtime: " + (System.currentTimeMillis() - t) + " milliseconds.");
|
||
}
|
||
|
||
}
|