static void updateMembers(Node * bypass, Node * nextNode)
{
PassageMarkerI marker, next, tmp;
Coordinate nextLength = getNodeLength(nextNode);
// Update marker + arc info
for (marker = getMarker(bypass); marker != NULL_IDX; marker = tmp) {
tmp = getNextInNode(marker);
if (!isTerminal(marker)
&& getNode(getNextInSequence(marker)) == nextNode) {
// Marker steps right into target
next = getNextInSequence(marker);
disconnectNextPassageMarker(marker, graph);
destroyPassageMarker(next);
} else if (getUniqueness(nextNode)
&& goesToNode(marker, nextNode)) {
// Marker goes indirectly to target
while (getNode(getNextInSequence(marker)) !=
nextNode) {
next = getNextInSequence(marker);
disconnectNextPassageMarker(marker, graph);
destroyPassageMarker(next);
}
next = getNextInSequence(marker);
disconnectNextPassageMarker(marker, graph);
destroyPassageMarker(next);
} else if (!isTerminal(marker)
&& getFinishOffset(marker) == 0) {
// Marker goes somewhere else than to target
next = getNextInSequence(marker);
incrementFinishOffset(marker, nextLength);
} else {
// Marker goes nowhere
incrementFinishOffset(marker, nextLength);
}
}
}
// Replaces two consecutive nodes into a single equivalent node
// The extra memory is freed
void concatenateNodes(Node * nodeA, Node * nodeB, Graph * graph)
{
PassageMarkerI marker, tmpMarker;
Node *twinA = getTwinNode(nodeA);
Node *twinB = getTwinNode(nodeB);
Arc *arc;
Category cat;
// Arc management:
// Freeing useless arcs
while (getArc(nodeA) != NULL)
destroyArc(getArc(nodeA), graph);
// Correct arcs
for (arc = getArc(nodeB); arc != NULL; arc = getNextArc(arc)) {
if (getDestination(arc) != twinB)
createAnalogousArc(nodeA, getDestination(arc),
arc, graph);
else
createAnalogousArc(nodeA, twinA, arc, graph);
}
// Passage marker management in node A:
for (marker = getMarker(nodeA); marker != NULL_IDX;
marker = getNextInNode(marker))
if (isTerminal(marker))
incrementFinishOffset(marker,
getNodeLength(nodeB));
// Swapping new born passageMarkers from B to A
for (marker = getMarker(nodeB); marker != NULL_IDX; marker = tmpMarker) {
tmpMarker = getNextInNode(marker);
if (isInitial(marker)
|| getNode(getPreviousInSequence(marker)) != nodeA) {
extractPassageMarker(marker);
transposePassageMarker(marker, nodeA);
incrementFinishOffset(getTwinMarker(marker),
getNodeLength(nodeA));
} else
disconnectNextPassageMarker(getPreviousInSequence
(marker), graph);
}
// Read starts
concatenateReadStarts(nodeA, nodeB, graph);
// Gaps
appendNodeGaps(nodeA, nodeB, graph);
// Descriptor management (node)
appendDescriptors(nodeA, nodeB);
// Update uniqueness:
setUniqueness(nodeA, getUniqueness(nodeA) || getUniqueness(nodeB));
// Update virtual coverage
for (cat = 0; cat < CATEGORIES; cat++)
incrementVirtualCoverage(nodeA, cat,
getVirtualCoverage(nodeB, cat));
// Update original virtual coverage
for (cat = 0; cat < CATEGORIES; cat++)
incrementOriginalVirtualCoverage(nodeA, cat,
getOriginalVirtualCoverage
(nodeB, cat));
// Freeing gobbled node
destroyNode(nodeB, graph);
}
// Replaces two consecutive nodes into a single equivalent node
// The extra memory is freed
void concatenateStringOfNodes(Node * nodeA, Graph * graph)
{
Node *twinA = getTwinNode(nodeA);
Node * nodeB = nodeA;
Node * twinB;
Node *currentNode, *nextNode;
Coordinate totalLength = 0;
PassageMarkerI marker, tmpMarker;
Arc *arc;
Category cat;
while (simpleArcCount(nodeB) == 1
&&
simpleArcCount(getTwinNode
(getDestination(getArc(nodeB)))) ==
1
&& getDestination(getArc(nodeB)) != getTwinNode(nodeB)
&& getDestination(getArc(nodeB)) != nodeA) {
totalLength += getNodeLength(nodeB);
nodeB = getDestination(getArc(nodeB));
}
twinB = getTwinNode(nodeB);
totalLength += getNodeLength(nodeB);
reallocateNodeDescriptor(nodeA, totalLength);
currentNode = nodeA;
while (currentNode != nodeB) {
currentNode = getDestination(getArc(currentNode));
// Passage marker management in node A:
for (marker = getMarker(nodeA); marker != NULL_IDX;
marker = getNextInNode(marker))
if (getNode(getNextInSequence(marker)) != currentNode)
incrementFinishOffset(marker,
getNodeLength(currentNode));
// Swapping new born passageMarkers from B to A
for (marker = getMarker(currentNode); marker != NULL_IDX; marker = tmpMarker) {
tmpMarker = getNextInNode(marker);
if (isInitial(marker)
|| getNode(getPreviousInSequence(marker)) != nodeA) {
extractPassageMarker(marker);
transposePassageMarker(marker, nodeA);
incrementFinishOffset(getTwinMarker(marker),
getNodeLength(nodeA));
} else
disconnectNextPassageMarker(getPreviousInSequence
(marker), graph);
}
// Read starts
concatenateReadStarts(nodeA, currentNode, graph);
// Gaps
appendNodeGaps(nodeA, currentNode, graph);
// Update uniqueness:
setUniqueness(nodeA, getUniqueness(nodeA) || getUniqueness(currentNode));
// Update virtual coverage
for (cat = 0; cat < CATEGORIES; cat++)
incrementVirtualCoverage(nodeA, cat,
getVirtualCoverage(currentNode, cat));
// Update original virtual coverage
for (cat = 0; cat < CATEGORIES; cat++)
incrementOriginalVirtualCoverage(nodeA, cat,
getOriginalVirtualCoverage
(currentNode, cat));
// Descriptor management (node)
directlyAppendDescriptors(nodeA, currentNode, totalLength);
}
// Correct arcs
for (arc = getArc(nodeB); arc != NULL; arc = getNextArc(arc)) {
if (getDestination(arc) != twinB)
createAnalogousArc(nodeA, getDestination(arc),
arc, graph);
else
createAnalogousArc(nodeA, twinA, arc, graph);
}
// Freeing gobbled nodes
currentNode = getTwinNode(nodeB);
while (currentNode != getTwinNode(nodeA)) {
arc = getArc(currentNode);
nextNode = getDestination(arc);
destroyNode(currentNode, graph);
currentNode = nextNode;
}
}
static Node *bypass()
{
Node *bypass = getNode(path);
Node *next = NULL;
Arc *arc;
PassageMarkerI nextMarker;
// Remove unwanted arcs
while (getArc(bypass) != NULL)
destroyArc(getArc(bypass), graph);
// Update extensive variables (length + descriptors + passage markers)
while (!isTerminal(path)) {
nextMarker = getNextInSequence(path);
next = getNode(nextMarker);
while (next == bypass) {
disconnectNextPassageMarker(path, graph);
destroyPassageMarker(nextMarker);
nextMarker = getNextInSequence(path);
next = getNode(nextMarker);
}
if (next == NULL)
return bypass;
// Overall node update
if (!getUniqueness(next)) {
adjustShortReads(bypass, getNextInSequence(path));
appendSequence(bypass, sequences,
getNextInSequence(path), graph);
} else {
concatenateReadStarts(bypass, next, graph);
#ifndef SINGLE_COV_CAT
Category cat;
for (cat = 0; cat < CATEGORIES; cat++) {
// Update virtual coverage
incrementVirtualCoverage(bypass, cat,
getVirtualCoverage(next, cat));
// Update original virtual coverage
incrementOriginalVirtualCoverage(bypass, cat,
getOriginalVirtualCoverage(next, cat));
}
#else
incrementVirtualCoverage(bypass, getVirtualCoverage(next));
#endif
appendDescriptors(bypass, next);
}
// Members
updateMembers(bypass, next);
// Termination
if (isTerminal(path) || getUniqueness(next))
break;
}
// Remove unique groupies from arrival
admitGroupies(next, bypass);
// Copy destination arcs
for (arc = getArc(next); arc != NULL; arc = getNextArc(arc)) {
if (getDestination(arc) == next)
continue;
else if (getDestination(arc) == getTwinNode(next))
createAnalogousArc(bypass, getTwinNode(bypass),
arc, graph);
else
createAnalogousArc(bypass, getDestination(arc),
arc, graph);
}
destroyNode(next, graph);
return bypass;
}