C++ slFreeList函数代码示例

struct bigBedInterval *bigBedNameQuery(struct bbiFile *bbi, struct bptFile *index,
    int fieldIx, char *name, struct lm *lm)
/* Return list of intervals matching file. These intervals will be allocated out of lm. */
{
struct fileOffsetSize *fosList = bigBedChunksMatchingName(bbi, index, name);
struct bigBedInterval *intervalList = bigBedIntervalsMatchingName(bbi, fosList, 
    bbWordMatchesName, fieldIx, name, lm);
slFreeList(&fosList);
return intervalList;
}

char *findSelDb()
/* Find user selected database (as opposed to genome database). */
{
struct slName *dbList = getDbListForGenome();
char *selDb = cartUsualString(cart, hgtaTrack, NULL);
if (!slNameInList(dbList, selDb))
    selDb = cloneString(dbList->name);
slFreeList(&dbList);
return selDb;
}

void gffGroupFree(struct gffGroup **pGroup)
/* Free up a gffGroup including lineList. */
{
struct gffGroup *group;
if ((group = *pGroup) != NULL)
    {
    slFreeList(&group->lineList);
    freez(pGroup);
    }
}

void lmCleanup(struct lm **pLm)
/* Clean up a local memory pool. */
{
    struct lm *lm = *pLm;
    if (lm == NULL)
        return;
    slFreeList(&lm->blocks);
    freeMem(lm);
    *pLm = NULL;
}

static void addImageListAndFree(struct visiSearcher *searcher,
	struct slInt *imageList, int startWord, int wordCount)
/* Add images in list to searcher with weight one.
 * Then free imageList */
{
struct slInt *image;
for (image = imageList; image != NULL; image = image->next)
    visiSearcherAdd(searcher, image->val, 1.0, startWord, wordCount);
slFreeList(&imageList);
}

static struct dlList *sortedListFromTree(struct rbTree *tree)
/* Create a double-linked list from tree. List will be sorted.  */
{
struct slRef *ref, *refList = rbTreeItems(tree);
struct dlList *list = dlListNew();
for (ref = refList; ref != NULL; ref = ref->next)
    dlAddValTail(list, ref->val);
slFreeList(&refList);
return list;
}

void joinerCheckTableCoverage(struct joiner *joiner, char *specificDb)
/* Check that all tables either are part of an identifier or
 * are in the tablesIgnored statements. */
{
    struct slName *miss, *missList = NULL;
    struct hashEl *dbList, *db;

    dbList = hashElListHash(joiner->databasesChecked);
    for (db = dbList; db != NULL; db = db->next)
    {
        if (specificDb == NULL || sameString(db->name, specificDb))
        {
            struct sqlConnection *conn = sqlMayConnect(db->name);
            if (conn == NULL)
                warn("Error: database %s doesn't exist", db->name);
            else
            {
                struct slName *table;
                struct slName *tableList = sqlListTables(conn);
                struct hash *hash = getCoveredTables(joiner, db->name, conn);
                for (table = tableList; table != NULL; table = table->next)
                {
                    if (!hashLookup(hash, table->name))
                    {
                        char fullName[256];
                        safef(fullName, sizeof(fullName), "%s.%s",
                              db->name, table->name);
                        miss = slNameNew(fullName);
                        slAddHead(&missList, miss);
                    }
                    else
                        verbose(2,"tableCovered: '%s'\n", table->name);
                }
                slFreeList(&tableList);
                freeHash(&hash);
                reportErrorList(&missList, "tables not in .joiner file");
            }
            sqlDisconnect(&conn);
        }
    }
    slFreeList(&dbList);
}

void userSettingsCapturePrefix(struct userSettings *us, char *prefix)
/* Capture all variables that start with prefix. */
{
struct hashEl *el, *list = cartFindPrefix(us->cart, prefix);
for (el = list; el != NULL; el = el->next)
     {
    struct slName *n = slNameNew(el->name);
    slAddHead(&us->saveList, n);
    }
slFreeList(&list);
}

void tableJoinerFree(struct tableJoiner **pTf)
/* Free up memory associated with tableJoiner. */
{
    struct tableJoiner *tj = *pTf;
    if (tj != NULL)
    {
        joinerDtfFreeList(&tj->fieldList);
        slFreeList(&tj->keysOut);
        freez(pTf);
    }
}

static void makeBigBedOrderedCommaFieldList(struct joinerDtf *dtfList,
        struct dyString *dy)
/* Make comma-separated field list in same order as fields are in
 * big bed. */
{
    struct sqlConnection *conn = hAllocConn(dtfList->database);
    struct slName *fieldList = bigBedGetFields(dtfList->table, conn);
    makeOrderedCommaFieldList(fieldList, dtfList, dy);
    slFreeList(&fieldList);
    hFreeConn(&conn);
}

char *wormGeneFirstOrfName(char *geneName)
/* Return first ORF synonym to gene. */
{
struct slName *synList = wormGeneToOrfNames(geneName);
char *name;
if (synList == NULL)
    return NULL;
name = cloneString(synList->name);
slFreeList(&synList);
return name;
}

static void dumpVertices(struct rbTree *vertexTree)
{
struct slRef *vRef, *vRefList = rbTreeItems(vertexTree);
for (vRef = vRefList; vRef != NULL; vRef = vRef->next)
    {
    struct vertex *v = vRef->val;
    printf(" %d(%d)", v->position, v->type);
    }
printf("\n");
slFreeList(&vRefList);
}

static void expInfoFree(struct expInfo **pExp)
/* Free up memory associated with expInfo. */
{
struct expInfo *exp = *pExp;
if (exp != NULL)
    {
    freeMem(exp->geneName);
    slFreeList(&exp->tissueList);
    freez(pExp);
    }
}

void freeCdnaAliList(struct cdnaAli **pList)
/* Free a list of alignments and associated data. */
{
struct cdnaAli *ca;
for (ca = *pList; ca != NULL; ca = ca->next)
    {
    ffFreeAli(&ca->ali);
    freeDnaSeq(&ca->cdna);
    }
slFreeList(pList);
}

/* free slRef objects in the compRangeMap */
static void destructCompRangeMap(struct malnSet *malnSet) {
    struct hashCookie cookie = hashFirst(malnSet->compRangeMap->hash);
    struct hashEl *hel;
    while ((hel = hashNext(&cookie)) != NULL) {
        struct rbTree *rangeTree = hel->val;
        for (struct range *rng = rangeTreeList(rangeTree); rng != NULL; rng = rng->next) {
            slFreeList(&rng->val);
        }
    }
    genomeRangeTreeFree(&malnSet->compRangeMap);
}