void flower_destruct(Flower *flower, int64_t recursive) {
Flower_GroupIterator *iterator;
Sequence *sequence;
End *end;
Block *block;
Group *group;
Chain *chain;
Flower *nestedFlower;
if (recursive) {
iterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(iterator)) != NULL) {
nestedFlower = group_getNestedFlower(group);
if (nestedFlower != NULL) {
flower_destruct(nestedFlower, recursive);
}
}
flower_destructGroupIterator(iterator);
}
cactusDisk_removeFlower(flower->cactusDisk, flower);
flower_destructFaces(flower);
stSortedSet_destruct(flower->faces);
assert(flower_getEventTree(flower) != NULL);
eventTree_destruct(flower_getEventTree(flower));
while ((sequence = flower_getFirstSequence(flower)) != NULL) {
sequence_destruct(sequence);
}
stSortedSet_destruct(flower->sequences);
while ((chain = flower_getFirstChain(flower)) != NULL) {
chain_destruct(chain);
}
stSortedSet_destruct(flower->chains);
while ((end = flower_getFirstEnd(flower)) != NULL) {
end_destruct(end);
}
stSortedSet_destruct(flower->caps);
stSortedSet_destruct(flower->ends);
while ((block = flower_getFirstBlock(flower)) != NULL) {
block_destruct(block);
}
stSortedSet_destruct(flower->segments);
stSortedSet_destruct(flower->blocks);
while ((group = flower_getFirstGroup(flower)) != NULL) {
group_destruct(group);
}
stSortedSet_destruct(flower->groups);
free(flower);
}
bool flower_removeIfRedundant(Flower *flower) {
if (!flower_isLeaf(flower) && flower_getParentGroup(flower) != NULL && flower_getBlockNumber(flower) == 0) { //We will remove this flower..
Group *parentGroup = flower_getParentGroup(flower); //This group will be destructed
//Deal with any parent chain..
if (group_isLink(parentGroup)) {
link_split(group_getLink(parentGroup));
}
Flower *parentFlower = group_getFlower(parentGroup); //We will add the groups in the flower to the parent
/*
* For each group in the flower we take its nested flower and attach it to the parent.
*/
Group *group;
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
//Copy the group into the parent..
Flower *nestedFlower = group_getNestedFlower(group);
assert(nestedFlower != NULL);
Group *newParentGroup = group_construct(parentFlower, nestedFlower);
flower_setParentGroup(nestedFlower, newParentGroup);
group_constructChainForLink(newParentGroup);
} else {
Group *newParentGroup = group_construct2(parentFlower);
End *end;
Group_EndIterator *endIt = group_getEndIterator(group);
while ((end = group_getNextEnd(endIt)) != NULL) {
End *parentEnd = flower_getEnd(parentFlower, end_getName(end));
assert(parentEnd != NULL);
end_setGroup(parentEnd, newParentGroup);
}
group_destructEndIterator(endIt);
group_constructChainForLink(newParentGroup);
}
}
flower_destructGroupIterator(groupIt);
//The group attached to the flower should now be empty
assert(group_getEndNumber(parentGroup) == 0);
group_destruct(parentGroup);
//Now wipe the flower out..
cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower);
flower_destruct(flower, 0);
return 1;
}
return 0;
}
void flower_delete2(Flower *flower, bool isOnDisk) {
Flower_GroupIterator *groupIt = flower_getGroupIterator(flower);
Group *group;
while ((group = flower_getNextGroup(groupIt)) != NULL) {
if (!group_isLeaf(group)) {
flower_delete2(group_getNestedFlower(group), isOnDisk);
}
}
flower_destructGroupIterator(groupIt);
Group *parentGroup = flower_getParentGroup(flower);
if(parentGroup != NULL) {
parentGroup->leafGroup = 1;
}
//This needs modification so that we don't do this directly..
if(isOnDisk) {
cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower);
}
flower_destruct(flower, 0);
}
void cactusDisk_destruct(CactusDisk *cactusDisk) {
Flower *flower;
MetaSequence *metaSequence;
while ((flower = stSortedSet_getFirst(cactusDisk->flowers)) != NULL) {
flower_destruct(flower, FALSE);
}
stSortedSet_destruct(cactusDisk->flowers);
stSortedSet_destruct(cactusDisk->flowerNamesMarkedForDeletion);
while ((metaSequence = stSortedSet_getFirst(cactusDisk->metaSequences)) != NULL) {
metaSequence_destruct(metaSequence);
}
stSortedSet_destruct(cactusDisk->metaSequences);
//close DB
stKVDatabase_destruct(cactusDisk->database);
//Close the sequences files.
if (cactusDisk->storeSequencesInAFile) {
free(cactusDisk->sequencesFileName);
free(cactusDisk->absSequencesFileName);
if (cactusDisk->sequencesReadFileHandle != NULL) {
fclose(cactusDisk->sequencesReadFileHandle);
}
if (cactusDisk->sequencesWriteFileHandle != NULL) {
fsync(fileno(cactusDisk->sequencesWriteFileHandle));
fclose(cactusDisk->sequencesWriteFileHandle);
}
} else {
assert(cactusDisk->sequencesFileName == NULL);
assert(cactusDisk->sequencesReadFileHandle == NULL);
assert(cactusDisk->absSequencesFileName == NULL);
}
stCache_destruct(cactusDisk->cache); //Get rid of the cache
stCache_destruct(cactusDisk->stringCache);
stList_destruct(cactusDisk->updateRequests);
free(cactusDisk);
}
bool flower_deleteIfEmpty(Flower *flower) {
if (flower_getEndNumber(flower) == 0 && flower_getParentGroup(flower) != NULL) { //contains nothing useful..
assert(flower_getChainNumber(flower) == 0);
assert(flower_getBlockNumber(flower) == 0);
while (flower_getGroupNumber(flower) > 0) {
Group *group = flower_getFirstGroup(flower);
if (!group_isLeaf(group)) {
bool i = flower_deleteIfEmpty(group_getNestedFlower(group));
(void) i;
assert(i);
}
}
assert(flower_getGroupNumber(flower) == 0);
//This needs modification so that we don't do this directly..
cactusDisk_deleteFlowerFromDisk(flower_getCactusDisk(flower), flower);
Group *parentGroup = flower_getParentGroup(flower);
group_destruct(parentGroup);
flower_destruct(flower, 0);
return 1;
}
return 0;
}
void flower_unload(Flower *flower) {
flower_destruct(flower, 0);
}
