static void freeContigList(struct dlList **pContigList)
/* Free up list of contigs. */
{
struct dlNode *node;
struct contig *contig;
for (node = (*pContigList)->head; node->next != NULL; node = node->next)
{
contig = node->val;
freeContig(&contig);
}
freeDlList(pContigList);
}
void freeDlListAndVals(struct dlList **pList)
/* Free all values in doubly linked list and the list itself. (Just calls
* freeMem on all values. */
{
struct dlList *list = *pList;
if (list != NULL)
{
struct dlNode *node;
for (node = list->head; node->next != NULL; node = node->next)
freeMem(node->val);
freeDlList(pList);
}
}
struct dgNodeRef *dgConstrainedPriorityOrder(struct diGraph *dg)
/* Return traversal of graph in priority order subject to
* constraint that all parents must be output before
* their children regardless of node priority.
* Graph must be cycle free. */
{
struct dlList *sortedList = newDlList();
struct dgNode *graphNode;
struct dlNode *listNode;
struct dgNodeRef *refList = NULL, *ref;
if (dgHasCycles(dg))
errAbort("Call to dgConstrainedPriorityOrder on graph with cycles.");
/* Make up list sorted by priority. */
for (graphNode = dg->nodeList; graphNode != NULL; graphNode = graphNode->next)
{
dlAddValTail(sortedList, graphNode);
graphNode->visited = FALSE;
}
dlSort(sortedList, cmpPriority);
/* Loop taking first member of list with no untraversed parents. */
while (!dlEmpty(sortedList))
{
for (listNode = sortedList->head; listNode->next != NULL; listNode = listNode->next)
{
graphNode = listNode->val;
if (dgParentsAllVisited(graphNode))
{
dlRemove(listNode);
freeMem(listNode);
AllocVar(ref);
ref->node = graphNode;
slAddHead(&refList, ref);
graphNode->visited = TRUE;
break;
}
}
}
freeDlList(&sortedList);
slReverse(&refList);
return refList;
}
void rudpFree(struct rudp **pRu)
/* Free up rudp. Note this does *not* close the associated socket. */
{
struct rudp *ru = *pRu;
if (ru->recvHash)
{
struct dlNode *node;
while (!dlEmpty(ru->recvList))
{
node = dlPopHead(ru->recvList);
struct packetSeen *p = node->val;
freeMem(node);
hashRemove(ru->recvHash, p->recvHashKey);
freePacketSeen(&p);
}
freeDlList(&ru->recvList);
hashFree(&ru->recvHash);
}
freez(pRu);
}
struct dgNodeRef *dgFindPath(struct diGraph *dg, struct dgNode *a, struct dgNode *b)
/* Find shortest path from a to b. Return NULL if can't be found. */
{
struct dgNodeRef *refList = NULL, *ref;
struct dgConnection *con;
struct dgNode *node, *nNode;
struct dlList *fifo;
struct dlNode *ffNode;
struct dgNode endNode;
int fifoSize = 1;
/* Do some quick and easy tests first to return if have no way out
* of node A, or if B directly follows A. */
if (a->nextList == NULL)
return NULL;
if (a == b)
{
AllocVar(ref);
ref->node = a;
return ref;
}
if ((con = dgFindNodeInConList(a->nextList, b)) != NULL)
{
AllocVar(refList);
refList->node = a;
node = con->node;
AllocVar(ref);
ref->node = node;
slAddTail(&refList, ref);
return refList;
}
/* Set up for breadth first traversal. Will use a doubly linked
* list as a fifo. */
for (node = dg->nodeList; node != NULL; node = node->next)
node->tempEntry = NULL;
fifo = newDlList();
dlAddValTail(fifo, a);
a->tempEntry = &endNode;
while ((ffNode = dlPopHead(fifo)) != NULL)
{
--fifoSize;
node = ffNode->val;
freeMem(ffNode);
for (con = node->nextList; con != NULL; con = con->next)
{
nNode = con->node;
if (nNode->tempEntry == NULL)
{
nNode->tempEntry = node;
if (nNode == b)
{
while (nNode != &endNode && nNode != NULL)
{
AllocVar(ref);
ref->node = nNode;
slAddHead(&refList, ref);
nNode = nNode->tempEntry;
}
break;
}
else
{
dlAddValTail(fifo, nNode);
++fifoSize;
if (fifoSize > 100000)
errAbort("Internal error in dgFindPath");
}
}
}
}
freeDlList(&fifo);
return refList;
}
