void flower_check(Flower *flower) {
eventTree_check(flower_getEventTree(flower));
Flower_GroupIterator *groupIterator = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
group_check(group);
}
flower_destructGroupIterator(groupIterator);
Flower_ChainIterator *chainIterator = flower_getChainIterator(flower);
Chain *chain;
while ((chain = flower_getNextChain(chainIterator)) != NULL) {
chain_check(chain);
}
flower_destructCapIterator(chainIterator);
//We check built trees in here.
Flower_EndIterator *endIterator = flower_getEndIterator(flower);
End *end;
while ((end = flower_getNextEnd(endIterator)) != NULL) {
end_check(end);
end_check(end_getReverse(end)); //We will test everything backwards also.
}
flower_destructEndIterator(endIterator);
if (flower_builtFaces(flower)) {
Flower_FaceIterator *faceIterator = flower_getFaceIterator(flower);
Face *face;
while ((face = flower_getNextFace(faceIterator)) != NULL) {
face_check(face);
}
flower_destructFaceIterator(faceIterator);
face_checkFaces(flower);
} else {
cactusCheck(flower_getFaceNumber(flower) == 0);
}
if (flower_builtBlocks(flower)) { //Note that a flower for which the blocks are not yet built must be a leaf.
Flower_BlockIterator *blockIterator = flower_getBlockIterator(flower);
Block *block;
while ((block = flower_getNextBlock(blockIterator)) != NULL) {
block_check(block);
block_check(block_getReverse(block)); //We will test everything backwards also.
}
flower_destructBlockIterator(blockIterator);
} else {
cactusCheck(flower_isLeaf(flower)); //Defensive
cactusCheck(flower_isTerminal(flower)); //Checks that a flower without built blocks is a leaf and does not
//contain any blocks.
}
Flower_SequenceIterator *sequenceIterator = flower_getSequenceIterator(flower);
Sequence *sequence;
while ((sequence = flower_getNextSequence(sequenceIterator)) != NULL) {
sequence_check(sequence);
}
flower_destructSequenceIterator(sequenceIterator);
}
/*
* Fill in a hashtable which to every node associates
* alist of lifted edges
*/
static stHash *buildFaces_computeLiftedEdges(Flower * flower) {
stHash *liftedEdgesTable = stHash_construct3(buildFaces_hashfunction,
buildFaces_key_eq_fn, NULL, buildFaces_destructValue);
Flower_CapIterator *iter = flower_getCapIterator(flower);
Cap *cap, *attachedAncestor;
Cap *adjacency, *adjacencyAncestor;
stList *liftedEdges;
LiftedEdge *liftedEdge;
// Iterate through potential bottom nodes
while ((cap = flower_getNextCap(iter))) {
// ... check if connected
if ((adjacency = cap_getAdjacency(cap))) {
// ... lift
attachedAncestor = cap_getTopCap(cap);
adjacencyAncestor = cap_getTopCap(cap_getPositiveOrientation(
adjacency));
#ifndef NDEBUG
assert((attachedAncestor && adjacencyAncestor) || (!attachedAncestor && !adjacencyAncestor));
#endif
// If root node
if (attachedAncestor == NULL)
continue;
// ... create lifted edge
liftedEdge = st_malloc(sizeof(LiftedEdge));
liftedEdge->destination = adjacencyAncestor;
liftedEdge->bottomNode = cap;
#ifndef NDEBUG
// Self loop
if (adjacencyAncestor == attachedAncestor)
abort();
#endif
// ... add it to the hashtable
if ((liftedEdges
= stHash_search(liftedEdgesTable, attachedAncestor))) {
stList_append(liftedEdges, liftedEdge);
} else {
liftedEdges = stList_construct3(2,
buildFaces_stList_destructElem);
stList_append(liftedEdges, liftedEdge);
stHash_insert(liftedEdgesTable, attachedAncestor, liftedEdges);
}
}
}
flower_destructCapIterator(iter);
return liftedEdgesTable;
}
void flower_reconstructFaces(Flower * flower) {
flower_destructFaces(flower);
stHash *liftedEdgesTable = buildFaces_computeLiftedEdges(flower);
Flower_CapIterator *iter = flower_getCapIterator(flower);
stList *liftedEdges;
Cap *current;
while ((current = flower_getNextCap(iter))) {
if ((liftedEdges = stHash_search(liftedEdgesTable, current))
&& (stList_length(liftedEdges) >= 1)) {
buildFaces_constructFromCap(current, liftedEdgesTable, flower);
}
}
stHash_destruct(liftedEdgesTable);
flower_destructCapIterator(iter);
}
