Event *eventTree_getCommonAncestor(Event *event, Event *event2) {
Event *ancestorEvent;
struct List *list;
assert(event != NULL);
assert(event2 != NULL);
assert(event_getEventTree(event) == event_getEventTree(event2));
list = constructEmptyList(0, NULL);
ancestorEvent = event;
while(ancestorEvent != NULL) {
if(ancestorEvent == event2) {
destructList(list);
return event2;
}
listAppend(list, ancestorEvent);
ancestorEvent = event_getParent(ancestorEvent);
}
ancestorEvent = event2;
while((ancestorEvent = event_getParent(ancestorEvent)) != NULL) {
if(listContains(list, ancestorEvent)) {
destructList(list);
return ancestorEvent;
}
}
destructList(list);
assert(FALSE);
return NULL;
}
void testEvent_getEventTree(CuTest* testCase) {
cactusEventTestSetup();
CuAssertTrue(testCase, event_getEventTree(rootEvent) == eventTree);
CuAssertTrue(testCase, event_getEventTree(internalEvent) == eventTree);
CuAssertTrue(testCase, event_getEventTree(leafEvent1) == eventTree);
CuAssertTrue(testCase, event_getEventTree(leafEvent2) == eventTree);
cactusEventTestTeardown();
}
void event_check(Event *event) {
EventTree *eventTree = event_getEventTree(event);
Event *ancestorEvent = event_getParent(event);
//Check event and eventree properly linked
cactusCheck(eventTree_getEvent(event_getEventTree(event), event_getName(event)) == event);
//Event has parent, unless it is root.
if (eventTree_getRootEvent(eventTree) == event) {
cactusCheck(ancestorEvent == NULL);
} else { //not root, so must have ancestor.
cactusCheck(ancestorEvent != NULL);
}
//Each child event has event as parent.
int64_t i = 0;
for (i = 0; i < event_getChildNumber(event); i++) {
Event *childEvent = event_getChild(event, i);
cactusCheck(event_getParent(childEvent) == event);
}
//Ancestor-event --> event edge is consistent with any event tree that is in the parent of the containing flower.
Group *parentGroup = flower_getParentGroup(eventTree_getFlower(
event_getEventTree(event)));
if (parentGroup != NULL) {
EventTree *parentEventTree = flower_getEventTree(group_getFlower(
parentGroup));
Event *parentEvent = eventTree_getEvent(parentEventTree, event_getName(
event));
if (parentEvent != NULL) {
if (ancestorEvent == NULL) { //the case where they are both root.
cactusCheck(eventTree_getRootEvent(parentEventTree) == parentEvent);
} else {
//Check edge ancestorEvent --> event is in parent event tree.
while (1) {
Event *parentAncestorEvent = eventTree_getEvent(
parentEventTree, event_getName(ancestorEvent));
if (parentAncestorEvent != NULL) {
cactusCheck(event_isAncestor(parentEvent, parentAncestorEvent));
break;
}
ancestorEvent = event_getParent(ancestorEvent);
cactusCheck(ancestorEvent != NULL);
}
}
}
}
}
void event_destruct(Event *event) {
int64_t i;
Event *childEvent;
Event *parentEvent = event_getParent(event);
if (parentEvent != NULL) {
listRemove(parentEvent->children, event);
}
eventTree_removeEvent(event_getEventTree(event), event);
for (i = 0; i < event->children->length; i++) {
childEvent = event->children->list[i];
childEvent->parent = parentEvent;
if (parentEvent != NULL) {
listAppend(parentEvent->children, childEvent);
}
}
destructList(event->children);
free(event->header);
free(event);
}
