/**
* Constructs a new date list of the specified type containing the dates in the specified list.
*
* @param list a list of dates to include in the new list
* @param type the type of the new list
*/
public DateList(final DateList list, final Value type) {
if (!Value.DATE.equals(type) && !Value.DATE_TIME.equals(type)) {
throw new IllegalArgumentException("Type must be either DATE or DATE-TIME");
}
this.type = type;
if (Value.DATE.equals(type)) {
for (Iterator i = list.iterator(); i.hasNext(); ) {
add(new Date((Date) i.next()));
}
} else {
for (Iterator i = list.iterator(); i.hasNext(); ) {
add(new DateTime((Date) i.next()));
}
}
}
static JAXBElement<? extends BasePropertyType> doProperty(
final Property prop, final PropertyInfoIndex pii, final boolean wrapXprops) throws Throwable {
if (prop instanceof XProperty) {
if (!wrapXprops) {
return null;
}
final XBedeworkWrapperPropType wrapper = new XBedeworkWrapperPropType();
wrapper.setText(prop.getValue());
processParameters(prop.getParameters(), wrapper);
final XBedeworkWrappedNameParamType wnp = new XBedeworkWrappedNameParamType();
wnp.setText(prop.getName());
if (wrapper.getParameters() == null) {
wrapper.setParameters(new ArrayOfParameters());
}
wrapper.getParameters().getBaseParameter().add(of.createXBedeworkWrappedName(wnp));
return of.createXBedeworkWrapper(wrapper);
}
switch (pii) {
case ACTION:
/* ------------------- Action: Alarm -------------------- */
ActionPropType a = new ActionPropType();
a.setText(prop.getValue());
return of.createAction(a);
case ATTACH:
/* ------------------- Attachments -------------------- */
// pl.add(setAttachment(att));
return null;
case ATTENDEE:
/* ------------------- Attendees -------------------- */
final AttendeePropType att = new AttendeePropType();
att.setCalAddress(prop.getValue());
return of.createAttendee(att);
case BUSYTYPE:
return null;
case CATEGORIES:
/* ------------------- Categories -------------------- */
// LANG - filter on language - group language in one cat list?
CategoriesPropType c = new CategoriesPropType();
CategoryList cats = ((Categories) prop).getCategories();
Iterator pit = cats.iterator();
while (pit.hasNext()) {
c.getText().add((String) pit.next());
}
return of.createCategories(c);
case CLASS:
/* ------------------- Class -------------------- */
ClassPropType cl = new ClassPropType();
cl.setText(prop.getValue());
return of.createClass(cl);
case COMMENT:
/* ------------------- Comments -------------------- */
CommentPropType cm = new CommentPropType();
cm.setText(prop.getValue());
return of.createComment(cm);
case COMPLETED:
/* ------------------- Completed -------------------- */
CompletedPropType cmp = new CompletedPropType();
cmp.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
return of.createCompleted(cmp);
case CONTACT:
/* ------------------- Contact -------------------- */
// LANG
ContactPropType ct = new ContactPropType();
ct.setText(prop.getValue());
return of.createContact(ct);
case CREATED:
/* ------------------- Created -------------------- */
CreatedPropType created = new CreatedPropType();
created.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
return of.createCreated(created);
case DESCRIPTION:
/* ------------------- Description -------------------- */
DescriptionPropType desc = new DescriptionPropType();
desc.setText(prop.getValue());
return of.createDescription(desc);
case DTEND:
/* ------------------- DtEnd -------------------- */
DtendPropType dtend = (DtendPropType) makeDateDatetime(new DtendPropType(), prop);
return of.createDtend(dtend);
case DTSTAMP:
/* ------------------- DtStamp -------------------- */
DtstampPropType dtstamp = new DtstampPropType();
dtstamp.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
return of.createDtstamp(dtstamp);
case DTSTART:
/* ------------------- DtStart -------------------- */
DtstartPropType dtstart = (DtstartPropType) makeDateDatetime(new DtstartPropType(), prop);
return of.createDtstart(dtstart);
case DUE:
/* ------------------- Due -------------------- */
DuePropType due = (DuePropType) makeDateDatetime(new DuePropType(), prop);
return of.createDue(due);
case DURATION:
/* ------------------- Duration -------------------- */
DurationPropType dur = new DurationPropType();
dur.setDuration(prop.getValue());
return of.createDuration(dur);
case EXDATE:
/* ------------------- ExDate --below------------ */
return null;
case EXRULE:
/* ------------------- ExRule --below------------- */
ExrulePropType er = new ExrulePropType();
er.setRecur(doRecur(((RRule) prop).getRecur()));
return of.createExrule(er);
case FREEBUSY:
/* ------------------- freebusy -------------------- */
FreeBusy icfb = (FreeBusy) prop;
PeriodList fbps = icfb.getPeriods();
if (Util.isEmpty(fbps)) {
return null;
}
FreebusyPropType fb = new FreebusyPropType();
String fbtype = paramVal(prop, Parameter.FBTYPE);
if (fbtype != null) {
ArrayOfParameters pars = getAop(fb);
FbtypeParamType f = new FbtypeParamType();
f.setText(fbtype);
JAXBElement<FbtypeParamType> param = of.createFbtype(f);
pars.getBaseParameter().add(param);
}
List<PeriodType> pdl = fb.getPeriod();
for (Object o : fbps) {
Period p = (Period) o;
PeriodType np = new PeriodType();
np.setStart(XcalUtil.getXMlUTCCal(p.getStart().toString()));
np.setEnd(XcalUtil.getXMlUTCCal(p.getEnd().toString()));
pdl.add(np);
}
return of.createFreebusy(fb);
case GEO:
/* ------------------- Geo -------------------- */
Geo geo = (Geo) prop;
GeoPropType g = new GeoPropType();
g.setLatitude(geo.getLatitude().floatValue());
g.setLatitude(geo.getLongitude().floatValue());
return of.createGeo(g);
case LAST_MODIFIED:
/* ------------------- LastModified -------------------- */
LastModifiedPropType lm = new LastModifiedPropType();
lm.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
return of.createLastModified(lm);
case LOCATION:
/* ------------------- Location -------------------- */
LocationPropType l = new LocationPropType();
l.setText(prop.getValue());
return of.createLocation(l);
case METHOD:
/* ------------------- Method -------------------- */
MethodPropType m = new MethodPropType();
m.setText(prop.getValue());
return of.createMethod(m);
case ORGANIZER:
/* ------------------- Organizer -------------------- */
OrganizerPropType org = new OrganizerPropType();
org.setCalAddress(prop.getValue());
return of.createOrganizer(org);
case PERCENT_COMPLETE:
/* ------------------- PercentComplete -------------------- */
PercentCompletePropType p = new PercentCompletePropType();
p.setInteger(BigInteger.valueOf(((PercentComplete) prop).getPercentage()));
return of.createPercentComplete(p);
case PRIORITY:
/* ------------------- Priority -------------------- */
PriorityPropType pr = new PriorityPropType();
pr.setInteger(BigInteger.valueOf(((Priority) prop).getLevel()));
return of.createPriority(pr);
case PRODID:
/* ------------------- Prodid -------------------- */
ProdidPropType prod = new ProdidPropType();
prod.setText(prop.getValue());
return of.createProdid(prod);
case RDATE:
/* ------------------- RDate ------------------- */
// XXX Todo
return null;
case RECURRENCE_ID:
/* ------------------- RecurrenceID -------------------- */
RecurrenceIdPropType ri = new RecurrenceIdPropType();
String strval = prop.getValue();
if (dateOnly(prop)) {
// RECUR - fix all day recurrences sometime
if (strval.length() > 8) {
// Try to fix up bad all day recurrence ids. - assume a local timezone
strval = strval.substring(0, 8);
}
ri.setDate(XcalUtil.fromDtval(strval));
} else {
XcalUtil.initDt(ri, strval, getTzid(prop));
}
return of.createRecurrenceId(ri);
case RELATED_TO:
/* ------------------- RelatedTo -------------------- */
RelatedToPropType rt = new RelatedToPropType();
String relType = paramVal(prop, Parameter.RELTYPE);
String value = paramVal(prop, Parameter.VALUE);
if ((value == null) || "uid".equalsIgnoreCase(value)) {
rt.setUid(prop.getValue());
} else if ("uri".equalsIgnoreCase(value)) {
rt.setUri(prop.getValue());
} else {
rt.setText(prop.getValue());
}
if (relType != null) {
ArrayOfParameters pars = getAop(rt);
ReltypeParamType r = new ReltypeParamType();
r.setText(relType);
JAXBElement<ReltypeParamType> param = of.createReltype(r);
pars.getBaseParameter().add(param);
}
return of.createRelatedTo(rt);
case REPEAT:
/* ------------------- Repeat Alarm -------------------- */
Repeat rept = (Repeat) prop;
RepeatPropType rep = new RepeatPropType();
rep.setInteger(BigInteger.valueOf(rept.getCount()));
return of.createRepeat(rep);
case REQUEST_STATUS:
/* ------------------- RequestStatus -------------------- */
// XXX Later
return null;
case RESOURCES:
/* ------------------- Resources -------------------- */
ResourcesPropType r = new ResourcesPropType();
List<String> rl = r.getText();
ResourceList rlist = ((Resources) prop).getResources();
Iterator rlit = rlist.iterator();
while (rlit.hasNext()) {
rl.add((String) rlit.next());
}
return of.createResources(r);
case RRULE:
/* ------------------- RRule ------------------- */
RrulePropType rrp = new RrulePropType();
rrp.setRecur(doRecur(((RRule) prop).getRecur()));
return of.createRrule(rrp);
case SEQUENCE:
/* ------------------- Sequence -------------------- */
SequencePropType s = new SequencePropType();
s.setInteger(BigInteger.valueOf(((Sequence) prop).getSequenceNo()));
return of.createSequence(s);
case STATUS:
/* ------------------- Status -------------------- */
StatusPropType st = new StatusPropType();
st.setText(prop.getValue());
return of.createStatus(st);
case SUMMARY:
/* ------------------- Summary -------------------- */
SummaryPropType sum = new SummaryPropType();
sum.setText(prop.getValue());
return of.createSummary(sum);
case TRIGGER:
/* ------------------- Trigger - alarm -------------------- */
TriggerPropType trig = new TriggerPropType();
String valType = paramVal(prop, Parameter.VALUE);
if ((valType == null) || (valType.equalsIgnoreCase(Value.DURATION.getValue()))) {
trig.setDuration(prop.getValue());
String rel = paramVal(prop, Parameter.RELATED);
if (rel != null) {
ArrayOfParameters pars = getAop(trig);
RelatedParamType rpar = new RelatedParamType();
rpar.setText(IcalDefs.alarmTriggerRelatedEnd);
JAXBElement<RelatedParamType> param = of.createRelated(rpar);
pars.getBaseParameter().add(param);
}
} else if (valType.equalsIgnoreCase(Value.DATE_TIME.getValue())) {
// t.setDateTime(val.getTrigger());
trig.setDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
}
return of.createTrigger(trig);
case TRANSP:
/* ------------------- Transp -------------------- */
TranspPropType t = new TranspPropType();
t.setText(prop.getValue());
return of.createTransp(t);
case TZID:
case TZNAME:
case TZOFFSETFROM:
case TZOFFSETTO:
case TZURL:
return null;
case UID:
/* ------------------- Uid -------------------- */
final UidPropType uid = new UidPropType();
uid.setText(prop.getValue());
return of.createUid(uid);
case URL:
/* ------------------- Url -------------------- */
final UrlPropType u = new UrlPropType();
u.setUri(prop.getValue());
return of.createUrl(u);
case VERSION:
/* ------------------- Version - vcal only -------------------- */
final VersionPropType vers = new VersionPropType();
vers.setText(prop.getValue());
return of.createVersion(vers);
case XBEDEWORK_COST:
/* ------------------- Cost -------------------- */
final XBedeworkCostPropType cst = new XBedeworkCostPropType();
cst.setText(prop.getValue());
return of.createXBedeworkCost(cst);
case X_BEDEWORK_CATEGORIES:
/* ------------------- Categories -------------------- */
final XBwCategoriesPropType xpcat = new XBwCategoriesPropType();
xpcat.getText().add(prop.getValue());
return of.createXBedeworkCategories(xpcat);
case X_BEDEWORK_CONTACT:
/* ------------------- Categories -------------------- */
final XBwContactPropType xpcon = new XBwContactPropType();
xpcon.setText(prop.getValue());
return of.createXBedeworkContact(xpcon);
case X_BEDEWORK_LOCATION:
/* ------------------- Categories -------------------- */
final XBwLocationPropType xploc = new XBwLocationPropType();
xploc.setText(prop.getValue());
return of.createXBedeworkLocation(xploc);
default:
if (prop instanceof XProperty) {
/* ------------------------- x-property --------------------------- */
/*
final PropertyInfoIndex xpii =
PropertyInfoIndex.fromName(prop.getName());
if (xpii == null) {
return null;
}
return null;*/
if (!wrapXprops) {
return null;
}
final XBedeworkWrapperPropType wrapper = new XBedeworkWrapperPropType();
processParameters(prop.getParameters(), wrapper);
return of.createXBedeworkWrapper(wrapper);
}
} // switch (pii)
return null;
}
/**
* Returns the the next date of this recurrence given a seed date and start date. The seed date
* indicates the start of the fist occurrence of this recurrence. The start date is the starting
* date to search for the next recurrence. Return null if there is no occurrence date after start
* date.
*
* @return the next date in the recurrence series after startDate
* @param seed the start date of this Recurrence's first instance
* @param startDate the date to start the search
*/
public final Date getNextDate(final Date seed, final Date startDate) {
final Calendar cal = Dates.getCalendarInstance(seed);
cal.setTime(seed);
// optimize the start time for selecting candidates
// (only applicable where a COUNT is not specified)
if (getCount() < 1) {
final Calendar seededCal = (Calendar) cal.clone();
while (seededCal.getTime().before(startDate)) {
cal.setTime(seededCal.getTime());
increment(seededCal);
}
}
int invalidCandidateCount = 0;
int noCandidateIncrementCount = 0;
Date candidate = null;
final Value value = seed instanceof DateTime ? Value.DATE_TIME : Value.DATE;
while (true) {
final Date candidateSeed = Dates.getInstance(cal.getTime(), value);
if (getUntil() != null && candidate != null && candidate.after(getUntil())) {
break;
}
if (getCount() > 0 && invalidCandidateCount >= getCount()) {
break;
}
if (Value.DATE_TIME.equals(value)) {
if (((DateTime) seed).isUtc()) {
((DateTime) candidateSeed).setUtc(true);
} else {
((DateTime) candidateSeed).setTimeZone(((DateTime) seed).getTimeZone());
}
}
final DateList candidates = getCandidates(candidateSeed, value);
if (!candidates.isEmpty()) {
noCandidateIncrementCount = 0;
// sort candidates for identifying when UNTIL date is exceeded..
Collections.sort(candidates);
for (final Iterator<Date> i = candidates.iterator(); i.hasNext(); ) {
candidate = i.next();
// don't count candidates that occur before the seed date..
if (!candidate.before(seed)) {
// Candidate must be after startDate because
// we want the NEXT occurrence
if (!candidate.after(startDate)) {
invalidCandidateCount++;
} else if (getCount() > 0 && invalidCandidateCount >= getCount()) {
break;
} else if (!(getUntil() != null && candidate.after(getUntil()))) {
return candidate;
}
}
}
} else {
noCandidateIncrementCount++;
if ((maxIncrementCount > 0) && (noCandidateIncrementCount > maxIncrementCount)) {
break;
}
}
increment(cal);
}
return null;
}