static stList *getSubstringsForFlowerSegments(stList *flowers) {
/*
* Get the set of substrings representing the strings in the segments of the given flowers.
*/
stList *substrings = stList_construct3(0, (void (*)(void *)) substring_destruct);
for (int64_t i = 0; i < stList_length(flowers); i++) {
Flower *flower = stList_get(flowers, i);
Flower_EndIterator *blockIt = flower_getBlockIterator(flower);
Block *block;
while ((block = flower_getNextBlock(blockIt)) != NULL) {
Block_InstanceIterator *instanceIt = block_getInstanceIterator(block);
Segment *segment;
while ((segment = block_getNext(instanceIt)) != NULL) {
Sequence *sequence;
if ((sequence = segment_getSequence(segment)) != NULL) {
segment = segment_getStrand(segment) ? segment : segment_getReverse(segment);
assert(segment_getLength(segment) > 0);
stList_append(substrings,
substring_construct(sequence_getMetaSequence(sequence)->stringName,
segment_getStart(segment) - sequence_getStart(sequence),
segment_getLength(segment)));
}
}
block_destructInstanceIterator(instanceIt);
}
flower_destructBlockIterator(blockIt);
}
return substrings;
}
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);
}
void flower_writeBinaryRepresentation(Flower *flower, void(*writeFn)(const void * ptr, size_t size, size_t count)) {
Flower_SequenceIterator *sequenceIterator;
Flower_EndIterator *endIterator;
Flower_BlockIterator *blockIterator;
Flower_GroupIterator *groupIterator;
Flower_ChainIterator *chainIterator;
Sequence *sequence;
End *end;
Block *block;
Group *group;
Chain *chain;
binaryRepresentation_writeElementType(CODE_FLOWER, writeFn);
binaryRepresentation_writeName(flower_getName(flower), writeFn);
binaryRepresentation_writeBool(flower_builtBlocks(flower), writeFn);
binaryRepresentation_writeBool(flower_builtTrees(flower), writeFn);
binaryRepresentation_writeBool(flower_builtFaces(flower), writeFn);
binaryRepresentation_writeName(flower->parentFlowerName, writeFn);
if (flower_getEventTree(flower) != NULL) {
eventTree_writeBinaryRepresentation(flower_getEventTree(flower), writeFn);
}
sequenceIterator = flower_getSequenceIterator(flower);
while ((sequence = flower_getNextSequence(sequenceIterator)) != NULL) {
sequence_writeBinaryRepresentation(sequence, writeFn);
}
flower_destructSequenceIterator(sequenceIterator);
endIterator = flower_getEndIterator(flower);
while ((end = flower_getNextEnd(endIterator)) != NULL) {
end_writeBinaryRepresentation(end, writeFn);
}
flower_destructEndIterator(endIterator);
blockIterator = flower_getBlockIterator(flower);
while ((block = flower_getNextBlock(blockIterator)) != NULL) {
block_writeBinaryRepresentation(block, writeFn);
}
flower_destructBlockIterator(blockIterator);
groupIterator = flower_getGroupIterator(flower);
while ((group = flower_getNextGroup(groupIterator)) != NULL) {
group_writeBinaryRepresentation(group, writeFn);
}
flower_destructGroupIterator(groupIterator);
chainIterator = flower_getChainIterator(flower);
while ((chain = flower_getNextChain(chainIterator)) != NULL) {
chain_writeBinaryRepresentation(chain, writeFn);
}
flower_destructChainIterator(chainIterator);
binaryRepresentation_writeElementType(CODE_FLOWER, writeFn); //this avoids interpretting things wrong.
}
int64_t flower_getTrivialChainNumber(Flower *flower) {
int64_t i = 0;
Flower_BlockIterator *blockIt = flower_getBlockIterator(flower);
Block *block;
while ((block = flower_getNextBlock(blockIt)) != NULL) {
if (block_isTrivialChain(block)) {
i++;
}
}
flower_destructBlockIterator(blockIt);
return i;
}
