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); }