timeparser.java

jrobin,使用纯java实现的RRD数据库,使用RRD数据库来统计数据.

/* ============================================================
 * JRobin : Pure java implementation of RRDTool's functionality
 * ============================================================
 *
 * Project Info:  http://www.jrobin.org
 * Project Lead:  Sasa Markovic ([e-mail]);
 *
 * (C) Copyright 2003-2005, by Sasa Markovic.
 *
 * Developers:    Sasa Markovic ([e-mail])
 *
 *
 * 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
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Java port of Tobi's original parsetime.c routine
 */
package org.jrobin.core.timespec;

import org.jrobin.core.RrdException;
import org.jrobin.core.Util;

/**
 * Class which parses at-style time specification (describided in detail on the rrdfetch man page),
 * used in all RRDTool commands. This code is in most parts just a java port of Tobi's parsetime.c
 * code.
 */
public class TimeParser {
	private static final int PREVIOUS_OP = -1;

	TimeToken token;
	TimeScanner scanner;
	TimeSpec spec;

	int op = TimeToken.PLUS;
	int prev_multiplier = -1;

	/**
	 * Constructs TimeParser instance from the given input string.
	 *
	 * @param dateString at-style time specification (read rrdfetch man page
	 *                   for the complete explanation)
	 */
	public TimeParser(String dateString) {
		scanner = new TimeScanner(dateString);
		spec = new TimeSpec(dateString);
	}

	private void expectToken(int desired, String errorMessage) throws RrdException {
		token = scanner.nextToken();
		if (token.id != desired) {
			throw new RrdException(errorMessage);
		}
	}

	private void plusMinus(int doop) throws RrdException {
		if (doop >= 0) {
			op = doop;
			expectToken(TimeToken.NUMBER, "There should be number after " +
					(op == TimeToken.PLUS ? '+' : '-'));
			prev_multiplier = -1; /* reset months-minutes guessing mechanics */
		}
		int delta = Integer.parseInt(token.value);
		token = scanner.nextToken();
		if (token.id == TimeToken.MONTHS_MINUTES) {
			/* hard job to guess what does that -5m means: -5mon or -5min? */
			switch (prev_multiplier) {
				case TimeToken.DAYS:
				case TimeToken.WEEKS:
				case TimeToken.MONTHS:
				case TimeToken.YEARS:
					token = scanner.resolveMonthsMinutes(TimeToken.MONTHS);
					break;
				case TimeToken.SECONDS:
				case TimeToken.MINUTES:
				case TimeToken.HOURS:
					token = scanner.resolveMonthsMinutes(TimeToken.MINUTES);
					break;
				default:
					if (delta < 6) {
						token = scanner.resolveMonthsMinutes(TimeToken.MONTHS);
					}
					else {
						token = scanner.resolveMonthsMinutes(TimeToken.MINUTES);
					}
			}
		}
		prev_multiplier = token.id;
		delta *= (op == TimeToken.PLUS) ? +1 : -1;
		switch (token.id) {
			case TimeToken.YEARS:
				spec.dyear += delta;
				break;
			case TimeToken.MONTHS:
				spec.dmonth += delta;
				break;
			case TimeToken.WEEKS:
				delta *= 7;
				/* FALLTHRU */
			case TimeToken.DAYS:
				spec.dday += delta;
				break;
			case TimeToken.HOURS:
				spec.dhour += delta;
				break;
			case TimeToken.MINUTES:
				spec.dmin += delta;
				break;
			case TimeToken.SECONDS:
			default: // default is 'seconds'
				spec.dsec += delta;
				break;
		}
		// unreachable statement
		// throw new RrdException("Well-known time unit expected after " + delta);
	}

	private void timeOfDay() throws RrdException {
		int hour, minute = 0;
		/* save token status in case we must abort */
		scanner.saveState();
		/* first pick out the time of day - we assume a HH (COLON|DOT) MM time */
		if (token.value.length() > 2) {
			return;
		}
		hour = Integer.parseInt(token.value);
		token = scanner.nextToken();
		if (token.id == TimeToken.SLASH || token.id == TimeToken.DOT) {
			/* guess we are looking at a date */
			token = scanner.restoreState();
			return;
		}
		if (token.id == TimeToken.COLON) {
			expectToken(TimeToken.NUMBER, "Parsing HH:MM syntax, expecting MM as number, got none");
			minute = Integer.parseInt(token.value);
			if (minute > 59) {
				throw new RrdException("Parsing HH:MM syntax, got MM = " +
						minute + " (>59!)");
			}
			token = scanner.nextToken();
		}
		/* check if an AM or PM specifier was given */
		if (token.id == TimeToken.AM || token.id == TimeToken.PM) {
			if (hour > 12) {
				throw new RrdException("There cannot be more than 12 AM or PM hours");
			}
			if (token.id == TimeToken.PM) {
				if (hour != 12) {
					/* 12:xx PM is 12:xx, not 24:xx */
					hour += 12;
				}
			}
			else {
				if (hour == 12) {
					/* 12:xx AM is 00:xx, not 12:xx */
					hour = 0;
				}
			}
			token = scanner.nextToken();
		}
		else if (hour > 23) {
			/* guess it was not a time then ... */
			token = scanner.restoreState();
			return;
		}
		spec.hour = hour;
		spec.min = minute;
		spec.sec = 0;
		if (spec.hour == 24) {
			spec.hour = 0;
			spec.day++;
		}
	}

	private void assignDate(long mday, long mon, long year) throws RrdException {
		if (year > 138) {
			if (year > 1970) {
				year -= 1900;
			}
			else {
				throw new RrdException("Invalid year " + year +
						" (should be either 00-99 or >1900)");
			}
		}
		else if (year >= 0 && year < 38) {
			year += 100;		 /* Allow year 2000-2037 to be specified as   */
		}						 /* 00-37 until the problem of 2038 year will */
		/* arise for unices with 32-bit time_t     */
		if (year < 70) {
			throw new RrdException("Won't handle dates before epoch (01/01/1970), sorry");
		}
		spec.year = (int) year;
		spec.month = (int) mon;
		spec.day = (int) mday;
	}

	private void day() throws RrdException {
		long mday = 0, wday, mon, year = spec.year;
		switch (token.id) {
			case TimeToken.YESTERDAY:
				spec.day--;
				/* FALLTRHU */
			case TimeToken.TODAY:	/* force ourselves to stay in today - no further processing */
				token = scanner.nextToken();
				break;
			case TimeToken.TOMORROW:
				spec.day++;
				token = scanner.nextToken();
				break;
			case TimeToken.JAN:
			case TimeToken.FEB:
			case TimeToken.MAR:
			case TimeToken.APR:
			case TimeToken.MAY:
			case TimeToken.JUN:
			case TimeToken.JUL:
			case TimeToken.AUG:
			case TimeToken.SEP:
			case TimeToken.OCT:
			case TimeToken.NOV:
			case TimeToken.DEC:
				/* do month mday [year] */
				mon = (token.id - TimeToken.JAN);
				expectToken(TimeToken.NUMBER, "the day of the month should follow month name");
				mday = Long.parseLong(token.value);
				token = scanner.nextToken();
				if (token.id == TimeToken.NUMBER) {
					year = Long.parseLong(token.value);
					token = scanner.nextToken();
				}
				else {
					year = spec.year;
				}
				assignDate(mday, mon, year);
				break;
			case TimeToken.SUN:
			case TimeToken.MON:
			case TimeToken.TUE:
			case TimeToken.WED:
			case TimeToken.THU:
			case TimeToken.FRI:
			case TimeToken.SAT:
				/* do a particular day of the week */
				wday = (token.id - TimeToken.SUN);
				spec.day += (wday - spec.wday);
				token = scanner.nextToken();
				break;
			case TimeToken.NUMBER:
				/* get numeric <sec since 1970>, MM/DD/[YY]YY, or DD.MM.[YY]YY */
				// int tlen = token.value.length();
				mon = Long.parseLong(token.value);
				if (mon > 10L * 365L * 24L * 60L * 60L) {
					spec.localtime(mon);
					token = scanner.nextToken();
					break;
				}
				if (mon > 19700101 && mon < 24000101) { /*works between 1900 and 2400 */
					year = mon / 10000;
					mday = mon % 100;
					mon = (mon / 100) % 100;
					token = scanner.nextToken();
				}
				else {
					token = scanner.nextToken();
					if (mon <= 31 && (token.id == TimeToken.SLASH || token.id == TimeToken.DOT)) {
						int sep = token.id;
						expectToken(TimeToken.NUMBER, "there should be " +
								(sep == TimeToken.DOT ? "month" : "day") +
								" number after " +
								(sep == TimeToken.DOT ? '.' : '/'));
						mday = Long.parseLong(token.value);
						token = scanner.nextToken();
						if (token.id == sep) {
							expectToken(TimeToken.NUMBER, "there should be year number after " +
									(sep == TimeToken.DOT ? '.' : '/'));
							year = Long.parseLong(token.value);
							token = scanner.nextToken();
						}
						/* flip months and days for European timing */
						if (sep == TimeToken.DOT) {
							long x = mday;
							mday = mon;
							mon = x;
						}
					}
				}
				mon--;
				if (mon < 0 || mon > 11) {
					throw new RrdException("Did you really mean month " + (mon + 1));
				}
				if (mday < 1 || mday > 31) {
					throw new RrdException("I'm afraid that " + mday +
							" is not a valid day of the month");
				}
				assignDate(mday, mon, year);
				break;
		}
	}

	/**
	 * Parses the input string specified in the constructor.
	 *
	 * @return Object representing parsed date/time.
	 * @throws RrdException Thrown if the date string cannot be parsed.
	 */
	public TimeSpec parse() throws RrdException {
		long now = Util.getTime();
		int hr = 0;
		/* this MUST be initialized to zero for midnight/noon/teatime */
		/* establish the default time reference */
		spec.localtime(now);
		token = scanner.nextToken();
		switch (token.id) {
			case TimeToken.PLUS:
			case TimeToken.MINUS:
				break; /* jump to OFFSET-SPEC part */
			case TimeToken.START:
				spec.type = TimeSpec.TYPE_START;
				/* FALLTHRU */
			case TimeToken.END:
				if (spec.type != TimeSpec.TYPE_START) {
					spec.type = TimeSpec.TYPE_END;
				}
				spec.year = spec.month = spec.day = spec.hour = spec.min = spec.sec = 0;
				/* FALLTHRU */
			case TimeToken.NOW:
				int time_reference = token.id;
				token = scanner.nextToken();
				if (token.id == TimeToken.PLUS || token.id == TimeToken.MINUS) {
					break;
				}
				if (time_reference != TimeToken.NOW) {
					throw new RrdException("Words 'start' or 'end' MUST be followed by +|- offset");
				}
				else if (token.id != TimeToken.EOF) {
					throw new RrdException("If 'now' is followed by a token it must be +|- offset");
				}
				break;
				/* Only absolute time specifications below */
			case TimeToken.NUMBER:
				timeOfDay();
				if (token.id != TimeToken.NUMBER) {
					break;
				}
				/* fix month parsing */
			case TimeToken.JAN:
			case TimeToken.FEB:
			case TimeToken.MAR:
			case TimeToken.APR:
			case TimeToken.MAY:
			case TimeToken.JUN:
			case TimeToken.JUL:
			case TimeToken.AUG:
			case TimeToken.SEP:
			case TimeToken.OCT:
			case TimeToken.NOV:
			case TimeToken.DEC:
				day();
				if (token.id != TimeToken.NUMBER) {
					break;
				}
				timeOfDay();
				break;

				/* evil coding for TEATIME|NOON|MIDNIGHT - we've initialized
				 * hr to zero up above, then fall into this case in such a
				 * way so we add +12 +4 hours to it for teatime, +12 hours
				 * to it for noon, and nothing at all for midnight, then
				 * set our rettime to that hour before leaping into the
				 * month scanner
				 */
			case TimeToken.TEATIME:
				hr += 4;
				/* FALLTHRU */
			case TimeToken.NOON:
				hr += 12;
				/* FALLTHRU */
			case TimeToken.MIDNIGHT:
				spec.hour = hr;
				spec.min = 0;
				spec.sec = 0;
				token = scanner.nextToken();
				day();
				break;
			default:
				throw new RrdException("Unparsable time: " + token.value);
		}

		/*
		 * the OFFSET-SPEC part
		 *
		 * (NOTE, the sc_tokid was prefetched for us by the previous code)
		 */
		if (token.id == TimeToken.PLUS || token.id == TimeToken.MINUS) {
			scanner.setContext(false);
			while (token.id == TimeToken.PLUS || token.id == TimeToken.MINUS ||
					token.id == TimeToken.NUMBER) {
				if (token.id == TimeToken.NUMBER) {
					plusMinus(PREVIOUS_OP);
				}
				else {
					plusMinus(token.id);
				}
				token = scanner.nextToken();
				/* We will get EOF eventually but that's OK, since
				token() will return us as many EOFs as needed */
			}
		}
		/* now we should be at EOF */
		if (token.id != TimeToken.EOF) {
			throw new RrdException("Unparsable trailing text: " + token.value);
		}
		return spec;
	}
}