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);
}
void writeManifest(char *fileName, struct tagStanza *stanza, char *dataDir)
/* Write out manifest file */
{
verbose(2, "Writing manifest %s\n", fileName);
/* Start up a json file */
FILE *f = mustOpen(fileName, "w");
boolean firstOut = TRUE;
fprintf(f, "{");
/* Write dir and version tags */
writeJsonTag(f, "dir", &firstOut);
writeJsonVal(f, dataDir, FALSE);
writeJsonTag(f, "version", &firstOut);
writeJsonVal(f, "1", TRUE);
/* Write out files array */
writeJsonTag(f, "files", &firstOut);
fputc('[', f);
boolean firstFile = TRUE;
struct slName *file, *list = tagMustFindValList(stanza, "assay.seq.files");
for (file = list; file != NULL; file = file->next)
{
if (firstFile)
firstFile = FALSE;
else
fputc(',', f);
boolean firstField = TRUE;
fputc('{', f);
writeJsonTag(f, "name", &firstField);
if (gUrls)
{
char fileName[FILENAME_LEN], ext[FILEEXT_LEN], path[PATH_LEN];
splitPath(file->name, NULL, fileName, ext);
safef(path, sizeof(path), "%s%s", fileName, ext);
writeJsonVal(f, path, FALSE);
}
else
writeJsonVal(f, file->name, FALSE);
char *format = guessFormatFromName(file->name);
if (format != NULL)
{
writeJsonTag(f, "format", &firstField);
writeJsonVal(f, format, FALSE);
}
fputc('}', f);
}
slFreeList(&list);
fputc(']', f);
/* Close up and go home */
fprintf(f, "}");
carefulClose(&f);
}
static void joinerTableFree(struct joinerTable **pTable)
/* Free up memory associated with joinerTable. */
{
struct joinerTable *table = *pTable;
if (table != NULL)
{
slFreeList(&table->dbList);
freeMem(table->table);
freez(pTable);
}
}
static void targetHitsFree(struct targetHits **pObj)
/* Free one target hits structure. */
{
struct targetHits *obj = *pObj;
if (obj != NULL)
{
freeMem(obj->name);
slFreeList(&obj->axtList);
freez(pObj);
}
}
static void checkFiles(struct gbConf *conf, boolean serverFileCheck, boolean clusterFileCheck,
boolean checkClusterMaster)
/* check for existence of files specified in variables */
{
struct slName *dbs = getGenomeDbs(conf);
if (serverFileCheck)
checkServerFiles(dbs, conf);
if (clusterFileCheck || checkClusterMaster)
checkClusterFiles(dbs, conf, checkClusterMaster);
slFreeList(&dbs);
}
static void visiGeneMatchContributor(struct visiSearcher *searcher,
struct sqlConnection *conn, struct slName *wordList)
/* Put images from contributors in wordList into searcher.
* We want the behavior to be such that if you give it two names
* say "Smith Mahoney" it will weigh those that match both
* names. We also want it so that if you include the initials
* after the last name either with or without periods that will
* set those matching the last name and initials. For
* instance "Smith JJ" or "Smith J.J." or "Smith J. J." all would
* match a particular John Jacob Smith, but not Francis K. Smith.
* Making this a little more interesting is a case like
* "smith li" which could either be two last names, or a last
* name followed by initials. We would want to match both
* cases. Finally, making it even more interesting, is the
* case where the last name is compound, like "Van Koppen" or
* "de la Cruz" and the like. Also don't forget the apostrophe
* containing names like O'Shea. */
{
struct slName *word;
struct dyString *query = dyStringNew(0);
int wordIx;
for (word = wordList, wordIx=0; word != NULL; wordIx++)
{
struct slName *nameList, *name;
int maxWordsUsed = 0;
dyStringClear(query);
dyStringPrintf(query, "select name from contributor where name like \"");
dyStringAppend(query, word->name);
dyStringAppend(query, " %\"");
nameList = sqlQuickList(conn, query->string);
if (nameList != NULL)
{
for (name = nameList; name != NULL; name = name->next)
{
int wordsUsed = countPartsUsedInName(name->name, word);
if (wordsUsed > maxWordsUsed)
maxWordsUsed = wordsUsed;
}
for (name = nameList; name != NULL; name = name->next)
{
if (countPartsUsedInName(name->name, word) == maxWordsUsed)
addImagesMatchingName(searcher, conn, query, name->name,
wordIx, maxWordsUsed);
}
while (--maxWordsUsed >= 0)
word = word->next;
}
else
word = word->next;
slFreeList(&nameList);
}
dyStringFree(&query);
}
int encodePeakNumFields(char *db, char *trackName)
/* Just quickly count th number of fields. */
{
struct sqlConnection *conn = hAllocConn(db);
struct slName *fieldNames = sqlFieldNames(conn, trackName);
int numFields = slCount(fieldNames);
hFreeConn(&conn);
if (sameString(fieldNames->name, "bin"))
numFields--;
slFreeList(&fieldNames);
return numFields;
}
void makeCdnaToGene(struct cdnaInfo *cdnaList)
/* Make cdna to gene translation file. */
{
struct hash *hash = newHash(12);
struct cdnaInfo *ci;
struct fineAli *fa;
struct geneHit *gh;
struct geneHitList *geneHitList = NULL;
struct geneHitList *ghl;
struct hashEl *he;
uglyf("Making cdnaToGene file<BR>\n");
for (ci = cdnaList; ci != NULL; ci = ci->next)
{
if (ci->isDupe)
continue;
for (fa = ci->fineAli; fa != NULL; fa = fa->next)
{
if (fa->isDupe || !fa->isGood)
continue;
if ((he = hashLookup(hash, fa->geneName)) == NULL)
{
AllocVar(ghl);
ghl->geneName = fa->geneName;
ghl->next = geneHitList;
geneHitList = ghl;
he = hashAdd(hash, fa->geneName, ghl);
}
ghl = (struct geneHitList *)(he->val);
AllocVar(gh);
gh->cdnaName = ci->name;
gh->chromOffset = fa->hStart;
gh->next = ghl->hits;
ghl->hits = gh;
}
}
slSort(&geneHitList, cmpGhlName);
for (ghl=geneHitList; ghl!=NULL; ghl = ghl->next)
{
slReverse(&ghl->hits);
slSort(&ghl->hits, cmpGhOffset);
fprintf(cdnaToGeneFile, "%s ", ghl->geneName);
for (gh = ghl->hits; gh != NULL; gh = gh->next)
fprintf(cdnaToGeneFile, "%s ", gh->cdnaName);
fprintf(cdnaToGeneFile, "\n");
}
freeHash(&hash);
slFreeList(&geneHitList);
uglyf("Done making cdnaToGene file<BR>\n");
}
boolean hasBinColumn(struct sqlConnection *conn, char* table)
/* check if a table has a bin column */
{
struct slName *fields = sqlListFields(conn, table);
struct slName *f;
boolean found = FALSE;
for (f = fields; (f != NULL) && (!found); f = f->next)
found = sameString(f->name, "bin");
slFreeList(&fields);
return found;
}
static void mapQueryPsl(struct psl* inPsl, struct chromBins *mapAlns,
FILE* outPslFh, FILE *mapInfoFh, FILE *mappingPslFh)
/* map a query psl to all targets */
{
static struct dyString *idBuf = NULL;
struct binElement *overMapAlns
= chromBinsFind(mapAlns, getMappingId(inPsl->tName, &idBuf), inPsl->tStart, inPsl->tEnd);
struct binElement *overMapAln;
for (overMapAln = overMapAlns; overMapAln != NULL; overMapAln = overMapAln->next)
mapPslPair(inPsl, (struct mapAln *)overMapAln->val, outPslFh, mapInfoFh, mappingPslFh);
slFreeList(&overMapAlns);
}
static void validateCgiUrls(struct htmlPage *page)
/* Make sure URLs in page follow basic CGI encoding rules. */
{
struct htmlForm *form;
struct slName *linkList = htmlPageLinks(page), *link;
for (form = page->forms; form != NULL; form = form->next)
validateCgiUrl(form->action);
for (link = linkList; link != NULL; link = link->next)
validateCgiUrl(link->name);
slFreeList(&linkList);
}
void makeDbOrderedCommaFieldList(struct sqlConnection *conn,
char *table, struct joinerDtf *dtfList, struct dyString *dy)
/* Assumes that dtfList all points to same table. This will return
* a comma-separated field list in the same order as the fields are
* in database. */
{
char *split = chromTable(conn, table);
struct slName *fieldList = sqlListFields(conn, split);
makeOrderedCommaFieldList(fieldList, dtfList, dy);
slFreeList(&fieldList);
freez(&split);
}
void chainFree(struct chain **pChain)
/* Free up a chain. */
{
struct chain *chain = *pChain;
if (chain != NULL)
{
slFreeList(&chain->blockList);
freeMem(chain->qName);
freeMem(chain->tName);
freez(pChain);
}
}
void crunchDirDir(char *dirDir, FILE *f)
/* Crunch dir of dirs . */
{
struct fileInfo *dirList = listDirX(dirDir, NULL, FALSE), *dir;
for (dir = dirList; dir != NULL; dir = dir->next)
{
struct fileInfo *fileList, *file;
char path[PATH_LEN];
struct namePos *posList = NULL, *pos;
int minPos = -1;
if (!dir->isDir)
{
warn("%s isn't a dir, skipping", dir->name);
continue;
}
if (sameString(dir->name, "CVS"))
continue; /* Skip CVS directories in test suite. */
safef(path, sizeof(path), "%s/%s", dirDir, dir->name);
fileList = listDirX(path, NULL, FALSE);
for (file = fileList; file != NULL; file = file->next)
{
if (file->isDir)
continue;
AllocVar(pos);
pos->name = file->name;
safef(path, sizeof(path), "%s/%s/%s", dirDir, dir->name, file->name);
pos->pos = firstLinePos(path);
slAddHead(&posList, pos);
}
slSort(&posList, namePosCmp);
for (pos = posList; pos != NULL; pos = pos->next)
{
safef(path, sizeof(path), "%s/%s/%s", dirDir, dir->name, pos->name);
minPos = crunchOne(path, f, dir->name, minPos+1);
}
slFreeList(&posList);
slFreeList(&fileList);
}
slFreeList(&dirList);
}
void trimFosmids(char *sangDir, char *outFile)
/* trimFosmids - Process Fosmid end reads to remove low quality bases and put in one big file. */
{
struct hash *hash = newHash(20);
struct fileInfo *dirList, *dirEl;
struct fileInfo *subList, *subEl;
struct fileInfo *faList, *faEl;
FILE *f = mustOpen(outFile, "w");
unsigned long totalSize = 0;
dirList = listDirX(sangDir, "*", TRUE);
for (dirEl = dirList; dirEl != NULL; dirEl = dirEl->next)
{
if (dirEl->isDir)
{
printf("%s", dirEl->name);
fflush(stdout);
subList = listDirX(dirEl->name, "*", TRUE);
for (subEl = subList; subEl != NULL; subEl = subEl->next)
{
if (subEl->isDir)
{
printf(".");
fflush(stdout);
faList = listDirX(subEl->name, "*.fasta", TRUE);
for (faEl = faList; faEl != NULL; faEl = faEl->next)
{
uglyf("%s\n", faEl->name);
// totalSize += filterByQual(faEl->name, f, 19, 15, hash);
}
slFreeList(&faList);
}
}
printf("\n");
slFreeList(&subList);
}
}
printf("Total size %lu bytes\n", totalSize);
fclose(f);
}
struct joinerPair *joinerRelate(struct joiner *joiner, char *database,
char *table)
/* Get list of all ways to link table in given database to other tables,
* possibly in other databases. */
{
struct joinerSet *js, *jsChain;
struct joinerField *jf, *jfBase;
struct joinerPair *jpList = NULL, *jp;
struct slRef *chainList, *chainEl;
/* Return list of self, children, and parents (but not siblings) */
#ifdef SCREWS_UP_SPLITS
if (!tableExists(database, table, NULL))
errAbort("%s.%s - table doesn't exist", database, table);
#endif
for (js = joiner->jsList; js != NULL; js = js->next)
{
if ((jfBase = joinerSetIncludesTable(js, database, table)) != NULL)
{
chainList = joinerSetInheritanceChain(js);
for (chainEl = chainList; chainEl != NULL; chainEl = chainEl->next)
{
jsChain = chainEl->val;
for (jf = jsChain->fieldList; jf != NULL; jf = jf->next)
{
struct slName *db;
for (db = jf->dbList; db != NULL; db = db->next)
{
if (joinerExclusiveCheck(joiner, database, db->name))
{
if (!sameString(database, db->name)
|| !sameString(table, jf->table))
{
if (tableExists(db->name, jf->table,
jf->splitPrefix))
{
jp = joinerToField(database, jfBase,
db->name, jf, jsChain);
slAddHead(&jpList, jp);
}
}
}
}
}
}
slFreeList(&chainList);
}
}
slReverse(&jpList);
return jpList;
}
