1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
|
#include "CalendarInvoker.h"
#include <glog/logging.h>
#ifdef BUILD_AS_PLUGINS
#include <Pluma/Connector.hpp>
#endif
namespace uscxml {
#ifdef BUILD_AS_PLUGINS
PLUMA_CONNECTOR
bool connect(pluma::Host& host) {
host.add( new CalendarInvokerProvider() );
return true;
}
#endif
CalendarInvoker::CalendarInvoker() {
_icalSet = NULL;
_icalComp = NULL;
}
CalendarInvoker::~CalendarInvoker() {
tthread::lock_guard<tthread::recursive_mutex> lock(_mutex);
std::set<std::string>::iterator _eventIdIter = _eventIds.begin();
while(_eventIdIter != _eventIds.end()) {
_interpreter->getDelayQueue()->cancelEvent(*_eventIdIter);
_eventIds.erase(_eventIdIter++);
}
std::map<std::string, CalendarEvent*>::iterator eventIter = _events.begin();
while(eventIter != _events.end()) {
delete eventIter->second;
eventIter++;
}
if (_icalComp)
icalcomponent_free(_icalComp);
};
boost::shared_ptr<InvokerImpl> CalendarInvoker::create(InterpreterImpl* interpreter) {
boost::shared_ptr<CalendarInvoker> invoker = boost::shared_ptr<CalendarInvoker>(new CalendarInvoker());
invoker->_interpreter = interpreter;
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
// invoker->_calFile = URL::tmpFile();
// invoker->_icalSet = icalfileset_new(invoker->_calFile.c_str());
// if (!invoker->_icalSet) {
// LOG(WARNING) << "Could not create new ical fileset: " << icalerror_perror();
// }
return invoker;
}
Data CalendarInvoker::getDataModelVariables() {
Data data;
return data;
}
void CalendarInvoker::send(const SendRequest& req) {
tthread::lock_guard<tthread::recursive_mutex> lock(_mutex);
}
void CalendarInvoker::cancel(const std::string sendId) {
tthread::lock_guard<tthread::recursive_mutex> lock(_mutex);
std::set<std::string>::iterator _eventIdIter = _eventIds.begin();
while(_eventIdIter != _eventIds.end()) {
_interpreter->getDelayQueue()->cancelEvent(*_eventIdIter);
_eventIds.erase(_eventIdIter++);
}
}
void CalendarInvoker::invoke(const InvokeRequest& req) {
tthread::lock_guard<tthread::recursive_mutex> lock(_mutex);
_icalComp = addIcal(req.content);
// dumpComponent(_icalComp);
setupEvents(_icalComp);
}
icalcomponent* CalendarInvoker::addIcal(const std::string& icalString) {
icalcomponent* root = icalparser_parse_string(icalString.c_str());
if (!root) {
LOG(WARNING) << "Could not parse ical data: " << icalerror_perror();
return NULL;
}
// icalerrorenum err;
// err = icalset_add_component(_icalSet, root);
// icalfileset_commit(_icalSet);
return root;
}
void CalendarInvoker::setupEvents(icalcomponent* comp) {
// dumpComponent(comp);
switch (icalcomponent_isa(comp)) {
case ICAL_VCALENDAR_COMPONENT:
case ICAL_XROOT_COMPONENT:
break;
case ICAL_VALARM_COMPONENT: {
break;
}
case ICAL_VEVENT_COMPONENT: {
// event to map
CalendarEvent* event = new CalendarEvent(comp);
_events[toStr((uintptr_t)event)] = event;
queueEvent(event);
break;
}
default:
// dumpComponent(comp);
break;
}
icalcomponent* child = icalcomponent_get_first_component(comp, ICAL_ANY_COMPONENT);
while(child) {
setupEvents(child);
child = icalcomponent_get_next_component(comp, ICAL_ANY_COMPONENT);
}
}
void CalendarInvoker::queueEvent(CalendarEvent* event) {
if (_events.find(toStr((uintptr_t)event)) == _events.end()) {
_events[toStr((uintptr_t)event)] = event;
}
time_t now = time(NULL);
struct icaltime_span span;
if (event->_nextSpan.start > 0) {
span = event->getNextDuration(event->_nextSpan.start + 1);
} else {
span = event->getNextDuration(now);
}
#if 0
if (span.end > 0) {
std::cout << "\t\t" << ctime(&span.start);
std::cout << "\t\t" << ctime(&span.end);
span = event->getNextDuration(span.end);
}
#endif
if (span.start <= 0 || span.end <= 0) {
event->_nextSpan.start = 0;
event->_nextSpan.end = 0;
return;
}
int beginSecs = span.start - now;
int endSecs = span.end - now;
if (beginSecs > endSecs) {
LOG(WARNING) << "Event ends before it starts";
return;
}
event->_nextSpan = span;
std::string beginEventId = event->getId() + "." + toStr(span.start) + ".started";
std::string endEventId = event->getId() + "." + toStr(span.end) + ".ended";
#if 0
beginSecs = 1;
endSecs = 2;
#endif
if (beginSecs > 0) {
_interpreter->getDelayQueue()->addEvent(beginEventId, CalendarInvoker::raiseEvent, beginSecs * 1000, this);
_eventIds.insert(beginEventId);
} else {
raiseEvent(this, beginEventId);
}
_interpreter->getDelayQueue()->addEvent(endEventId, CalendarInvoker::raiseEvent, endSecs * 1000, this);
_eventIds.insert(endEventId);
}
void CalendarInvoker::raiseEvent(void* userdata, const std::string eventId) {
CalendarInvoker* INSTANCE = (CalendarInvoker*)userdata;
tthread::lock_guard<tthread::recursive_mutex> lock(INSTANCE->_mutex);
std::string address = eventId.substr(0, eventId.find_first_of("."));
if (INSTANCE->_events.find(address) == INSTANCE->_events.end()) {
LOG(WARNING) << "No such event: " << eventId;
return;
}
if(INSTANCE->_eventIds.find(eventId) != INSTANCE->_eventIds.end()) {
INSTANCE->_eventIds.erase(eventId);
}
CalendarEvent* calEvent = INSTANCE->_events[address];
Event event;
event.data = *calEvent;
if (boost::ends_with(eventId, ".started")) {
event.name = "event.started." + calEvent->getId();
assert(!calEvent->_active);
calEvent->_active = true;
} else {
event.name = "event.ended." + calEvent->getId();
assert(calEvent->_active);
calEvent->_active = false;
}
INSTANCE->returnEvent(event);
// event ended, reschedule next event
if (boost::ends_with(eventId, ".ended"))
INSTANCE->queueEvent(calEvent);
}
/**
* Get the next duration for this event starting no earlier
* than the given time.
*/
icaltime_span CalendarEvent::getNextDuration(time_t time) {
if (!_icalComp)
return icaltime_span_new(icaltime_null_time(), icaltime_null_time(), 0);
// see icalcomponent_foreach_recurrence
icalproperty *rrule;
icaltimetype calTime = icaltime_from_timet_with_zone(time, 0, 0);
// actual occurence, without reocurrence
if (!icalproperty_recurrence_is_excluded(_icalComp, &_dtstart, &_dtend)) {
if (icaltime_compare(_dtstart, calTime) >= 0) {
// start is still in the future
return icaltime_span_new(_dtstart, _dtend, 0);
}
}
icaltime_span recDur = icaltime_span_new(icaltime_null_time(), icaltime_null_time(), 0);
// iterate all rrules
for (rrule = icalcomponent_get_first_property(_icalComp, ICAL_RRULE_PROPERTY);
rrule != NULL;
rrule = icalcomponent_get_next_property(_icalComp, ICAL_RRULE_PROPERTY)) {
struct icalrecurrencetype recurType = icalproperty_get_rrule(rrule);
icalrecur_iterator *ritr;
struct icaltimetype rtime;
// do we have an old iterator that has not yet passed time?
if (_recIters.find(rrule) != _recIters.end()) {
if (_recIters[rrule].second > time) {
icalrecur_iterator_free(_recIters[rrule].first);
_recIters[rrule].first = icalrecur_iterator_new(recurType, _dtstart);
// skip initial non-reoccurence
if(_recIters[rrule].first)
rtime = icalrecur_iterator_next(_recIters[rrule].first);
}
ritr = _recIters[rrule].first;
} else {
// create a new iterator for this rrule
_recIters[rrule] = std::make_pair(icalrecur_iterator_new(recurType, _dtstart), 0);
ritr = _recIters[rrule].first;
}
// std::cout << icalrecurrencetype_as_string(&recurType) << std::endl;
while (ritr) {
rtime = icalrecur_iterator_next(ritr);
#if 0
time_t tt = icaltime_as_timet(rtime);
std::cout << "\t\t" << ctime(&tt);
#endif
if (icaltime_is_null_time(rtime)) {
// remove iterator
icalrecur_iterator_free(_recIters[rrule].first);
_recIters.erase(rrule);
break; // for next rule
}
_recIters[rrule].second = icaltime_as_timet(rtime);
if (icaltime_compare(rtime, calTime) < 0)
continue; // until we are after given time
if (icalproperty_recurrence_is_excluded(_icalComp, &_dtstart, &rtime))
continue;
icaltime_span thisDur = icaltime_span_new(rtime, rtime, 1);
thisDur.end += _dtduration;
if (recDur.start == 0 || thisDur.start < recDur.start) {
// update soonest reoccurence with the one from this rule
recDur = thisDur;
}
break; // we are after the event
}
}
return recDur;
}
CalendarEvent::~CalendarEvent() {
std::map<icalproperty*, std::pair<icalrecur_iterator*, time_t> >::iterator recItersIter = _recIters.begin();
while(recItersIter != _recIters.end()) {
icalrecur_iterator_free(recItersIter->second.first);
recItersIter++;
}
}
CalendarEvent::CalendarEvent(icalcomponent* icalComp) {
_nextSpan.start = 0;
_nextSpan.end = 0;
_icalComp = NULL;
_active = false;
_dtstart = icalcomponent_get_dtstart(icalComp);
_dtend = icalcomponent_get_dtend(icalComp);
if (!icaltime_is_valid_time(_dtstart)) {
LOG(WARNING) << "Start of event not a valid time";
return;
}
if (!icaltime_is_valid_time(_dtend)) {
LOG(WARNING) << "End of event not a valid time";
return;
}
_dtduration = icaldurationtype_as_int(icaltime_subtract(_dtend, _dtstart));
if (_dtduration <= 0) {
LOG(WARNING) << "Event has negative or zero duration";
return;
}
_icalComp = icalComp;
// initialize all iterators - not really needed anymore
for (icalproperty* rrule = icalcomponent_get_first_property(_icalComp, ICAL_RRULE_PROPERTY);
rrule != NULL;
rrule = icalcomponent_get_next_property(_icalComp, ICAL_RRULE_PROPERTY)) {
struct icalrecurrencetype recurType = icalproperty_get_rrule(rrule);
icalrecur_iterator *ritr = icalrecur_iterator_new(recurType, _dtstart);
_recIters[rrule] = std::make_pair(ritr, 0);
}
}
CalendarEvent::operator Data() {
Data data;
data = CalendarInvoker::toData(_icalComp);
return data;
}
Data CalendarInvoker::toData(icalcomponent* comp) {
Data data;
data.compound["kind"] = Data(icalcomponent_kind_to_string(icalcomponent_isa(comp)), Data::VERBATIM);
// iterate all properties
icalproperty* prop = icalcomponent_get_first_property(comp, ICAL_ANY_PROPERTY);
while(prop) {
std::string propName = icalproperty_kind_to_string(icalproperty_isa(prop));
boost::to_lower(propName);
#if 0
// iterate all parameters
icalparameter* para = icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER);
while(para) {
std::string paraName = icalparameter_kind_to_string(icalparameter_isa(para));
switch(icalparameter_get_value(para)) {
case ICAL_VALUE_X:
data.compound[propName].compound[paraName] = Data(icalparameter_get_x(para), Data::VERBATIM);
break;
case ICAL_VALUE_BOOLEAN:
case ICAL_VALUE_BINARY:
case ICAL_VALUE_DATE:
case ICAL_VALUE_DURATION:
case ICAL_VALUE_FLOAT:
case ICAL_VALUE_INTEGER:
case ICAL_VALUE_PERIOD:
case ICAL_VALUE_RECUR:
case ICAL_VALUE_TEXT:
case ICAL_VALUE_URI:
case ICAL_VALUE_ERROR:
case ICAL_VALUE_DATETIME:
case ICAL_VALUE_UTCOFFSET:
case ICAL_VALUE_CALADDRESS:
case ICAL_VALUE_NONE:
data.compound[propName].compound[paraName] = Data("", Data::VERBATIM);
break;
}
para = icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER);
}
data.compound[propName].compound["value"] = Data(icalproperty_get_value_as_string(prop), Data::VERBATIM);
#endif
#if 0
data.compound[propName] = Data(icalproperty_as_ical_string(prop), Data::VERBATIM);
#endif
data.compound[propName] = Data(icalproperty_get_value_as_string(prop), Data::VERBATIM);
prop = icalcomponent_get_next_property(comp, ICAL_ANY_PROPERTY);
}
icalcomponent* child = icalcomponent_get_first_component(comp, ICAL_ANY_COMPONENT);
while(child) {
data.compound["childs"].array.push_back(toData(child));
child = icalcomponent_get_next_component(comp, ICAL_ANY_COMPONENT);
}
return data;
}
void CalendarInvoker::dumpComponent(icalcomponent* comp) {
std::cout << icalcomponent_kind_to_string(icalcomponent_isa(comp)) << std::endl;
struct icaltimetype start, end;
time_t tt;
icalproperty *startProp = icalcomponent_get_first_property(comp, ICAL_DTSTART_PROPERTY);
if (startProp) {
start = icalproperty_get_dtstart(startProp);
}
icalproperty *endProp = icalcomponent_get_first_property(comp, ICAL_DTEND_PROPERTY);
if (endProp) {
end = icalproperty_get_dtend(endProp);
}
icalproperty *prop = icalcomponent_get_first_property(comp, ICAL_ANY_PROPERTY);
while(prop) {
std::cout << "\t" << icalproperty_kind_to_string(icalproperty_isa(prop)) << std::endl;
switch (icalproperty_isa(prop)) {
case ICAL_ANY_PROPERTY:
case ICAL_ACKNOWLEDGED_PROPERTY:
case ICAL_ACTION_PROPERTY:
case ICAL_ALLOWCONFLICT_PROPERTY:
case ICAL_ATTACH_PROPERTY:
case ICAL_ATTENDEE_PROPERTY:
case ICAL_CALID_PROPERTY:
case ICAL_CALMASTER_PROPERTY:
case ICAL_CALSCALE_PROPERTY:
case ICAL_CAPVERSION_PROPERTY:
case ICAL_CARLEVEL_PROPERTY:
case ICAL_CARID_PROPERTY:
case ICAL_CATEGORIES_PROPERTY:
case ICAL_CLASS_PROPERTY:
case ICAL_CMD_PROPERTY:
case ICAL_COMMENT_PROPERTY:
case ICAL_COMPLETED_PROPERTY:
case ICAL_COMPONENTS_PROPERTY:
case ICAL_CONTACT_PROPERTY:
case ICAL_CREATED_PROPERTY:
case ICAL_CSID_PROPERTY:
case ICAL_DATEMAX_PROPERTY:
case ICAL_DATEMIN_PROPERTY:
case ICAL_DECREED_PROPERTY:
case ICAL_DEFAULTCHARSET_PROPERTY:
case ICAL_DEFAULTLOCALE_PROPERTY:
case ICAL_DEFAULTTZID_PROPERTY:
case ICAL_DEFAULTVCARS_PROPERTY:
case ICAL_DENY_PROPERTY:
break;
case ICAL_DESCRIPTION_PROPERTY:
std::cout << "\t\t" << icalproperty_get_description(prop) << std::endl;
break;
case ICAL_DTEND_PROPERTY: {
end = icalproperty_get_dtend(prop);
tt = icaltime_as_timet(start);
std::cout << "\t\t" << ctime(&tt) << std::endl;
break;
}
case ICAL_DTSTAMP_PROPERTY:
break;
case ICAL_DTSTART_PROPERTY: {
start = icalproperty_get_dtstart(prop);
tt = icaltime_as_timet(start);
std::cout << "\t\t" << ctime(&tt) << std::endl;
break;
}
case ICAL_DUE_PROPERTY:
case ICAL_DURATION_PROPERTY:
case ICAL_EXDATE_PROPERTY:
case ICAL_EXPAND_PROPERTY:
case ICAL_EXRULE_PROPERTY:
case ICAL_FREEBUSY_PROPERTY:
case ICAL_GEO_PROPERTY:
case ICAL_GRANT_PROPERTY:
case ICAL_ITIPVERSION_PROPERTY:
case ICAL_LASTMODIFIED_PROPERTY:
case ICAL_LOCATION_PROPERTY:
case ICAL_MAXCOMPONENTSIZE_PROPERTY:
case ICAL_MAXDATE_PROPERTY:
case ICAL_MAXRESULTS_PROPERTY:
case ICAL_MAXRESULTSSIZE_PROPERTY:
case ICAL_METHOD_PROPERTY:
case ICAL_MINDATE_PROPERTY:
case ICAL_MULTIPART_PROPERTY:
case ICAL_NAME_PROPERTY:
case ICAL_ORGANIZER_PROPERTY:
case ICAL_OWNER_PROPERTY:
case ICAL_PERCENTCOMPLETE_PROPERTY:
case ICAL_PERMISSION_PROPERTY:
case ICAL_PRIORITY_PROPERTY:
case ICAL_PRODID_PROPERTY:
case ICAL_QUERY_PROPERTY:
case ICAL_QUERYLEVEL_PROPERTY:
case ICAL_QUERYID_PROPERTY:
case ICAL_QUERYNAME_PROPERTY:
case ICAL_RDATE_PROPERTY:
case ICAL_RECURACCEPTED_PROPERTY:
case ICAL_RECUREXPAND_PROPERTY:
case ICAL_RECURLIMIT_PROPERTY:
case ICAL_RECURRENCEID_PROPERTY:
case ICAL_RELATEDTO_PROPERTY:
case ICAL_RELCALID_PROPERTY:
case ICAL_REPEAT_PROPERTY:
case ICAL_REQUESTSTATUS_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
case ICAL_RESTRICTION_PROPERTY:
break;
case ICAL_RRULE_PROPERTY: {
// struct icaltimetype start = icaltime_from_timet(1,0);
// struct icaltimetype start = icalproperty_get_dtstart(icalcomponent_get_first_property(comp,ICAL_DTSTART_PROPERTY));
// struct icaltimetype end = icaltime_today();
struct icalrecurrencetype recur = icalproperty_get_rrule(prop);
struct icaltimetype next;
icalrecur_iterator* ritr;
for(ritr = icalrecur_iterator_new(recur,start),
next = icalrecur_iterator_next(ritr);
!icaltime_is_null_time(next);
next = icalrecur_iterator_next(ritr)) {
tt = icaltime_as_timet(next);
printf(" %s",ctime(&tt ));
}
icalrecur_iterator_free(ritr);
break;
}
case ICAL_SCOPE_PROPERTY:
case ICAL_SEQUENCE_PROPERTY:
case ICAL_STATUS_PROPERTY:
case ICAL_STORESEXPANDED_PROPERTY:
case ICAL_SUMMARY_PROPERTY:
case ICAL_TARGET_PROPERTY:
case ICAL_TRANSP_PROPERTY:
case ICAL_TRIGGER_PROPERTY:
case ICAL_TZID_PROPERTY:
case ICAL_TZNAME_PROPERTY:
case ICAL_TZOFFSETFROM_PROPERTY:
case ICAL_TZOFFSETTO_PROPERTY:
case ICAL_TZURL_PROPERTY:
case ICAL_UID_PROPERTY:
case ICAL_URL_PROPERTY:
case ICAL_VERSION_PROPERTY:
case ICAL_X_PROPERTY:
case ICAL_XLICCLASS_PROPERTY:
case ICAL_XLICCLUSTERCOUNT_PROPERTY:
case ICAL_XLICERROR_PROPERTY:
case ICAL_XLICMIMECHARSET_PROPERTY:
case ICAL_XLICMIMECID_PROPERTY:
case ICAL_XLICMIMECONTENTTYPE_PROPERTY:
case ICAL_XLICMIMEENCODING_PROPERTY:
case ICAL_XLICMIMEFILENAME_PROPERTY:
case ICAL_XLICMIMEOPTINFO_PROPERTY:
case ICAL_NO_PROPERTY:
break;
}
prop = icalcomponent_get_next_property(comp, ICAL_ANY_PROPERTY);
}
switch (icalcomponent_isa(comp)) {
case ICAL_NO_COMPONENT:
case ICAL_ANY_COMPONENT:
break;
case ICAL_XROOT_COMPONENT: {
icalcomponent* child = icalcomponent_get_first_component(comp, ICAL_ANY_COMPONENT);
while(child) {
dumpComponent(child);
child = icalcomponent_get_next_component(comp, ICAL_ANY_COMPONENT);
}
break;
}
case ICAL_XATTACH_COMPONENT:
case ICAL_VEVENT_COMPONENT:
case ICAL_VTODO_COMPONENT:
case ICAL_VJOURNAL_COMPONENT:
case ICAL_VCALENDAR_COMPONENT:
case ICAL_VAGENDA_COMPONENT:
case ICAL_VFREEBUSY_COMPONENT:
case ICAL_VALARM_COMPONENT:
case ICAL_XAUDIOALARM_COMPONENT:
case ICAL_XDISPLAYALARM_COMPONENT:
case ICAL_XEMAILALARM_COMPONENT:
case ICAL_XPROCEDUREALARM_COMPONENT:
case ICAL_VTIMEZONE_COMPONENT:
case ICAL_XSTANDARD_COMPONENT:
case ICAL_XDAYLIGHT_COMPONENT:
case ICAL_X_COMPONENT:
case ICAL_VSCHEDULE_COMPONENT:
case ICAL_VQUERY_COMPONENT:
case ICAL_VREPLY_COMPONENT:
case ICAL_VCAR_COMPONENT:
case ICAL_VCOMMAND_COMPONENT:
case ICAL_XLICINVALID_COMPONENT:
case ICAL_XLICMIMEPART_COMPONENT:
break;
}
}
}
|