Java ExceptionDates类代码示例

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected ICalParameters _prepareParameters(ExceptionDates property, WriteContext context) {
	if (isInObservance(context)) {
		return property.getParameters();
	}

	boolean hasTime;
	if (property.getValues().isEmpty()) {
		hasTime = false;
	} else {
		hasTime = (dataType(property, context.getVersion()) == DATE_TIME);
	}
	return handleTzidParameter(property, hasTime, context);
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected ICalDataType _dataType(ExceptionDates property, ICalVersion version) {
	List<ICalDate> dates = property.getValues();
	if (!dates.isEmpty()) {
		return dates.get(0).hasTime() ? DATE_TIME : DATE;
	}

	return defaultDataType(version);
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected String writeValue(ExceptionDates property, ICalDate value, WriteContext context) {
	if (isInObservance(context)) {
		return date(value).observance(true).extended(false).write();
	}

	return date(value, property, context).extended(false).write();
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected ICalDate readValue(ExceptionDates property, String value, ICalDataType dataType, ICalParameters parameters, ParseContext context) {
	ICalDate date;
	try {
		boolean hasTime = (dataType == DATE_TIME);
		date = date(value).hasTime(hasTime).parse();
	} catch (IllegalArgumentException e) {
		throw new CannotParseException(19);
	}
	context.addDate(date, property, parameters);

	return date;
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected ExceptionDates _parseJson(JCalValue value, ICalDataType dataType, ICalParameters parameters, ParseContext context) {
	List<String> valueStrs = value.asMulti();

	ExceptionDates property = new ExceptionDates();
	List<ICalDate> values = property.getValues();
	for (String valueStr : valueStrs) {
		ICalDate date = readValue(property, valueStr, dataType, parameters, context);
		values.add(date);
	}
	return property;
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Test
public void getDateIterator() {
	TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");

	VEvent event = new VEvent();

	event.setDateStart(date("2016-03-25 14:00:00", tz));

	event.setRecurrenceRule(new Recurrence.Builder(Frequency.DAILY).count(10).build());

	RecurrenceDates rdate = new RecurrenceDates();
	rdate.getDates().add(new ICalDate(date("2016-03-26 20:00:00", tz)));
	rdate.getDates().add(new ICalDate(date("2016-03-27 20:00:00", tz)));
	event.addRecurrenceDates(rdate);

	ExceptionDates exdate = new ExceptionDates();
	exdate.getValues().add(new ICalDate(date("2016-03-27 14:00:00", tz)));
	event.addExceptionDates(exdate);

	ExceptionRule exrule = new ExceptionRule(new Recurrence.Builder(Frequency.WEEKLY).count(2).build());
	event.addProperty(exrule);

	//@formatter:off
	List<Date> expectedList = Arrays.asList(
		date("2016-03-26 14:00:00", tz),
		date("2016-03-26 20:00:00", tz),
		date("2016-03-27 20:00:00", tz),
		date("2016-03-28 14:00:00", tz),
		date("2016-03-29 14:00:00", tz),
		date("2016-03-30 14:00:00", tz),
		date("2016-03-31 14:00:00", tz),
		date("2016-04-02 14:00:00", tz),
		date("2016-04-03 14:00:00", tz)
	);
	//@formatter:on

	assertIteratorEquals(expectedList, Google2445Utils.getDateIterator(event, TimeZone.getTimeZone("UTC")));
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
private final Check<ExceptionDates> has(final ICalDate... dates) {
	return new Check<ExceptionDates>() {
		public void check(ExceptionDates actual, ParseContext context) {
			assertEquals(Arrays.asList(dates), actual.getValues());
		}
	};
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
private final Check<ExceptionDates> is(final ExceptionDates expected) {
	return new Check<ExceptionDates>() {
		public void check(ExceptionDates actual, ParseContext context) {
			assertEquals(expected.getValues(), actual.getValues());
		}
	};
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
private Check<ExceptionDates> dateTimeWithTimezone(final boolean extended) {
	return new Check<ExceptionDates>() {
		public void check(ExceptionDates property, ParseContext context) {
			assertEquals(0, context.getFloatingDates().size());

			ListMultimap<String, TimezonedDate> timezonedDates = context.getTimezonedDates();
			assertEquals(1, timezonedDates.keySet().size());
			List<TimezonedDate> dates = context.getTimezonedDates().get("id");
			assertEquals(2, dates.size());
			assertTrue(dates.contains(new TimezonedDate(icalDate("2014-10-26T12:00:00"), property)));
			assertTrue(dates.contains(new TimezonedDate(icalDate("2014-10-26T14:00:00"), property)));
		}
	};
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
private Check<ExceptionDates> dateTimeWithoutTimezone(final boolean extended) {
	return new Check<ExceptionDates>() {
		public void check(ExceptionDates property, ParseContext context) {
			Collection<TimezonedDate> floating = context.getFloatingDates();
			assertEquals(2, floating.size());
			assertTrue(floating.contains(new TimezonedDate(icalDate("2014-10-26T12:00:00"), property)));
			assertTrue(floating.contains(new TimezonedDate(icalDate("2014-10-26T14:00:00"), property)));

			assertEquals(0, context.getTimezonedDates().size());
		}
	};
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
/**
 * extract the exception dates
 * 
 * @param e
 * @return
 */
private static List<Date> extractExceptionDates(VEvent e) {
	List<Date> dateList = new ArrayList<Date>();

	List<ExceptionDates> exceptionDates = e.getExceptionDates();
	if (exceptionDates != null) {
		for (ExceptionDates ed : exceptionDates) {
			dateList.addAll(ed.getValues());
		}
	}
	return dateList;
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
/**
 * @param VEvent
 *            event
 * @param TimeZone
 *            tz
 * @return
 */
private static String buildExdate(VEvent event, TimeZone tz) {

	List<ExceptionDates> exceptionDates = event.getExceptionDates();
	if (exceptionDates != null) {

		StringBuilder sb = new StringBuilder();
		List<Date> dates = extractExceptionDates(event);

		if (tz != null) {
			sb.append("TZID=").append(tz.getID()).append(':');
		}

		for (Iterator<Date> iterator = dates.iterator(); iterator.hasNext();) {
			Date date = (Date) iterator.next();

			sb.append(parseIcalDateToString(date, tz));

			if (iterator.hasNext()) {
				sb.append(",");
			}
		}
		return sb.toString();
	}

	return "";
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
public ExceptionDatesScribe() {
	super(ExceptionDates.class, "EXDATE");
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
@Override
protected ExceptionDates newInstance(ICalDataType dataType, ICalParameters parameters) {
	return new ExceptionDates();
}
 

import biweekly.property.ExceptionDates; //导入依赖的package包/类
protected List<ExceptionDates> parseExceptionDates(String property, TimeZone tz) throws ParseException {

		RDateList exDateList = new RDateList(property, tz);

		Calendar calUtc = Calendar.getInstance(TimeZone.getTimeZone("UTC"));

		ExceptionDates exDates = new ExceptionDates();

		for (DateValue exDate: exDateList.getDatesUtc()) {
			calUtc.clear();
			calUtc.set(exDate.year(), exDate.month(), exDate.day());
			exDates.addValue(calUtc.getTime());
		}

		List<ExceptionDates> listExDates = new ArrayList<ExceptionDates>();
		listExDates.add(exDates);

		return listExDates;
	}