static void addCluster(struct lm *lm, struct peakItem *itemList, int start, int end,
struct peakCluster **pList)
/* Make cluster of all items that overlap start/end, and put it on list. */
{
struct peakCluster *cluster;
lmAllocVar(lm, cluster);
double score = 0.0;
double maxSubScore = 0.0;
struct slRef *refList = NULL, *ref;
struct peakItem *item;
for (item = itemList; item != NULL; item = item->next)
{
if (rangeIntersection(start, end, item->chromStart, item->chromEnd) > 0)
{
lmAllocVar(lm, ref);
ref->val = item;
slAddHead(&refList, ref);
score += item->score;
if (item->score > maxSubScore) maxSubScore = item->score;
}
}
slReverse(&refList);
cluster->chrom = itemList->chrom;
cluster->chromStart = start;
cluster->chromEnd = end;
cluster->itemRefList = refList;
cluster->score = score;
cluster->maxSubScore = maxSubScore;
slAddHead(pList, cluster);
}
struct edge *edgeFromConsensusOfEvidence(struct rbTree *vertexTree, struct evidence *evList,
struct lm *lm)
/* Attempt to create a single edge from a list of overlapping evidence ranges.
* The start will be the consensus of all evidence starts. Likewise
* the end will be the consensus of all evidence ends. The evidence that
* overlaps this edge will be included in the edge. */
{
/* Gather up lists of starts and ends. */
struct sourceAndPos *startList = NULL, *endList = NULL;
struct evidence *ev, *nextEv;
int listSize = 0;
for (ev = evList; ev != NULL; ev = ev->next)
{
struct sourceAndPos *x;
boolean trusted = trustedSource(ev->lb->sourceType);
lmAllocVar(lm, x);
x->position = ev->start;
x->trustedSource = trusted;
slAddHead(&startList, x);
lmAllocVar(lm, x);
x->position = ev->end;
x->trustedSource = trusted;
slAddHead(&endList, x);
++listSize;
}
/* Get consensus starts and ends. */
slSort(&startList, sourceAndPosCmp);
struct vertex *start = consensusVertex(vertexTree, startList, listSize, ggSoftStart);
slSort(&endList, sourceAndPosCmpRev);
struct vertex *end = consensusVertex(vertexTree, endList, listSize, ggSoftEnd);
/* Make edge */
struct edge *edge;
AllocVar(edge);
edge->start = start;
edge->end = end;
edge->next = NULL;
/* Add overlapping evidence to edge. */
for (ev = evList; ev != NULL; ev = nextEv)
{
nextEv = ev->next;
if (rangeIntersection(ev->start, ev->end, start->position, end->position) > 0)
slAddHead(&edge->evList, ev);
}
return edge;
}
void assocGroupAdd(struct assocGroup *ag, char *key, char *val)
/* Add key/val pair to assocGroup. */
{
struct assocList *al = hashFindVal(ag->listHash, key);
struct slRef *ref;
if (al == NULL)
{
lmAllocVar(ag->lm, al);
hashAdd(ag->listHash, key, al);
}
val = hashStoreName(ag->valStringHash, val);
lmAllocVar(ag->lm, ref);
ref->val = val;
slAddHead(&al->list, ref);
}
static struct joinedRow *jrRowAdd(struct joinedTables *joined, char **row,
int fieldCount, int keyCount)
/* Add new row to joinable table. */
{
if (joined->maxRowCount != 0 && joined->rowCount >= joined->maxRowCount)
{
warn("Stopping after %d rows, try restricting region or adding filter",
joined->rowCount);
return NULL;
}
else
{
struct joinedRow *jr;
int i;
struct lm *lm = joined->lm;
lmAllocVar(lm, jr);
lmAllocArray(lm, jr->fields, joined->fieldCount);
lmAllocArray(lm, jr->keys, joined->keyCount);
jr->passedFilter = TRUE;
for (i=0; i<fieldCount; ++i)
jr->fields[i] = lmSlName(lm, row[i]);
row += fieldCount;
for (i=0; i<keyCount; ++i)
jr->keys[i] = lmSlName(lm, row[i]);
slAddHead(&joined->rowList, jr);
joined->rowCount += 1;
return jr;
}
}
void peakClusterMakerAddFromSource(struct peakClusterMaker *maker, struct peakSource *source)
/* Read through data source and add items to it to rangeTrees in maker */
{
struct hash *chromHash = maker->chromHash;
struct lineFile *lf = lineFileOpen(source->dataSource, TRUE);
struct lm *lm = chromHash->lm; /* Local memory pool - share with hash */
char *row[source->minColCount];
struct peakItem *item;
char *line;
while (lineFileNextReal(lf, &line))
{
char *asciiLine = lmCloneString(lm, line);
int wordCount = chopByWhite(line, row, source->minColCount);
lineFileExpectAtLeast(lf, source->minColCount, wordCount);
char *chrom = row[source->chromColIx];
struct hashEl *hel = hashLookup(chromHash, chrom);
if (hel == NULL)
{
struct rbTree *tree = rangeTreeNewDetailed(lm, maker->stack);
hel = hashAdd(chromHash, chrom, tree);
}
struct rbTree *tree = hel->val;
lmAllocVar(lm, item);
item->chrom = hel->name;
item->chromStart = sqlUnsigned(row[source->startColIx]);
item->chromEnd = sqlUnsigned(row[source->endColIx]);
item->score = sqlDouble(row[source->scoreColIx]) * source->normFactor;
if (item->score > 1000) item->score = 1000;
item->source = source;
item->asciiLine = asciiLine;
rangeTreeAddValList(tree, item->chromStart, item->chromEnd, item);
}
lineFileClose(&lf);
}
static void loadPolyASizeRec(struct hash *pasHash, char **row)
/* load one polyA size record into the hash table. This
* places in hash localmem to reduce memory usage */
{
struct polyASize pas, *pasRec;
struct hashEl *recHel;
polyASizeStaticLoad(row, &pas);
recHel = hashStore(pasHash, pas.id);
if (recHel->val != NULL)
{
/* record already exists for this id, validate */
pasRec = recHel->val;
if ((pasRec->seqSize != pas.seqSize)
||(pasRec->tailPolyASize != pas.tailPolyASize)
|| (pasRec->headPolyTSize != pas.headPolyTSize))
errAbort("multiple polyA size records for %s with different data", pas.id);
}
else
{
/* add new record */
lmAllocVar(pasHash->lm, pasRec);
pasRec->id = recHel->name;
pasRec->seqSize = pas.seqSize;
pasRec->tailPolyASize = pas.tailPolyASize;
pasRec->headPolyTSize = pas.headPolyTSize;
}
}
static struct rbTree *getNewRepeats(char *dirName, char *chrom)
/* Read in repeatMasker .out line format file into a tree of ranges. */
/* Handles lineage-specific files that preserve header */
{
struct rbTree *tree = rbTreeNew(simpleRangeCmp);
struct simpleRange *range;
char fileName[512];
struct lineFile *lf;
char *row[7];
boolean headerDone = FALSE;
sprintf(fileName, "%s/%s.out.spec", dirName, chrom);
lf = lineFileOpen(fileName, TRUE);
while (lineFileRow(lf, row))
{
/* skip header lines (don't contain numeric first field) */
if (!headerDone && atoi(row[0]) == 0)
continue;
if (!sameString(chrom, row[4]))
errAbort("Expecting %s word 5, line %d of %s\n",
chrom, lf->lineIx, lf->fileName);
headerDone = TRUE;
lmAllocVar(tree->lm, range);
range->start = lineFileNeedNum(lf, row, 5) - 1;
range->end = lineFileNeedNum(lf, row, 6);
rbTreeAdd(tree, range);
}
lineFileClose(&lf);
return tree;
}
void hashTest(int count)
/* Do hash-based version. */
{
char name[8];
int i, j;
struct hash *hash = hashNew(16);
struct lm *lm = hash->lm;
for (i=0; i<count; ++i)
{
int *pt;
lmAllocVar(lm, pt);
*pt = i;
sprintf(name, "%x", i);
hashAdd(hash, name, pt);
}
for (j=0; j<10; ++j)
{
for (i=0; i<count; ++i)
{
sprintf(name, "%x", i);
if (!hashLookup(hash, name))
errAbort("Couldn't find %s in hash", name);
}
}
}
struct hash *allChainsHash(char *fileName)
/* Hash all the chains in a given file by their ids. */
{
struct hash *chainHash = newHash(18);
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct chain *chain;
char chainId[20];
struct lm *lm = chainHash->lm;
struct rbTreeNode **stack;
lmAllocArray(lm, stack, 128);
while ((chain = chainRead(lf)) != NULL)
{
struct indexedChain *ixc;
lmAllocVar(lm, ixc);
ixc->chain = chain;
#ifdef SOON
#endif /* SOON */
ixc->blockTree = rangeTreeNewDetailed(lm, stack);
struct cBlock *block;
for (block = chain->blockList; block != NULL; block = block->next)
{
struct range *r = rangeTreeAdd(ixc->blockTree, block->tStart, block->tEnd);
r->val = block;
}
safef(chainId, sizeof(chainId), "%x", chain->id);
hashAddUnique(chainHash, chainId, ixc);
}
lineFileClose(&lf);
return chainHash;
}
void mgcStatusTblAdd(struct mgcStatusTbl *mst, unsigned imageId,
struct mgcStatusType *status, char *acc,
char *organism, char* geneName)
/* Add an entry to the table. acc maybe NULL */
{
struct mgcStatus *ms;
lmAllocVar(mst->lm, ms);
ms->imageId = imageId;
ms->status = status;
if ((acc != NULL) && (acc[0] != '\0'))
ms->acc = lmCloneString(mst->lm, acc);
else
ms->acc = NULL;
safef(ms->organism, sizeof(ms->organism), "%s", organism);
if ((geneName != NULL) && (geneName[0] != '\0'))
ms->geneName = lmCloneString(mst->lm, geneName);
else
ms->geneName = NULL;
if (mst->imageIdHash != NULL)
{
char key[64];
makeKey(imageId, key);
hashAdd(mst->imageIdHash, key, ms);
}
if ((mst->accHash != NULL) && (acc != NULL))
hashAdd(mst->accHash, ms->acc, ms);
}
static struct brokenRefPep *brokenRefPepObtain(struct brokenRefPepTbl *brpTbl,
char *protAcc, int protSeqId,
short protVer)
/* get a brokenRefPep object if it exists, or create a new one. protSeqId
* is 0 if not known, protVer is -1 if not known.*/
{
struct hashEl *hel = hashStore(brpTbl->protAccHash, protAcc);
struct brokenRefPep *brp = hel->val;
if (brp == NULL)
{
lmAllocVar(brpTbl->protAccHash->lm, brp);
hel->val = brp;
brp->protSeqId = protSeqId;
brp->protAcc = hel->name;
brp->protVer = protVer;
brp->newFaId = -1;
brp->newFaOff = -1;
}
else
{
/* exists, update ids if needed */
if ((protSeqId > 0) && (brp->protSeqId > 0) && (protSeqId != brp->protSeqId))
errAbort("%s protSeqId mismatch", protAcc);
if (brp->protSeqId == 0)
brp->protSeqId = protSeqId;
if ((protVer >= 0) && (brp->protVer >= 0) && (protVer != brp->protVer))
errAbort("%s protVer mismatch", protAcc);
if (brp->protVer < 0)
brp->protVer = protVer;
}
return brp;
}
static void parseRow(struct gbRelease* release, struct gbIgnore* ignore,
struct lineFile* lf, char **row)
/* read and parse a gbidx file record */
{
struct gbIgnoreAcc *igAcc;
struct hashEl *hel;
unsigned srcDb = 0;
/* determine srcDb, skip if it doesn't match release */
if (sameString(row[IGIDX_SRCDB_COL], "GenBank"))
srcDb = GB_GENBANK;
else if (sameString(row[IGIDX_SRCDB_COL], "RefSeq"))
srcDb = GB_REFSEQ;
else
errAbort("ignored srcdb must be \"GenBank\" or \"RefSeq\", got \"%s\":"
" %s:%u", row[IGIDX_SRCDB_COL], lf->fileName, lf->lineIx);
if (srcDb == release->srcDb)
{
if (ignore->accHash == NULL)
ignore->accHash = hashNew(IGNORE_HASH_SIZE);
hel = hashStore(ignore->accHash, row[IGIDX_ACC_COL]);
lmAllocVar(ignore->accHash->lm, igAcc);
igAcc->acc = hel->name;
igAcc->modDate = gbParseDate(lf, row[IGIDX_MODDATE_COL]);
igAcc->srcDb = srcDb;
slAddHead((struct gbIgnoreAcc**)&hel->val, igAcc);
}
}
struct dnaSeq *genePredToGenomicSequence(struct genePred *pred, char *chromSeq, struct lm *lm)
/* Return concatenated genomic sequence of exons of pred. */
{
int txLen = 0;
int i;
for (i=0; i < pred->exonCount; i++)
txLen += (pred->exonEnds[i] - pred->exonStarts[i]);
char *seq = lmAlloc(lm, txLen + 1);
int offset = 0;
for (i=0; i < pred->exonCount; i++)
{
int blockStart = pred->exonStarts[i];
int blockSize = pred->exonEnds[i] - blockStart;
memcpy(seq+offset, chromSeq+blockStart, blockSize*sizeof(*seq));
offset += blockSize;
}
if(pred->strand[0] == '-')
reverseComplement(seq, txLen);
struct dnaSeq *txSeq = NULL;
lmAllocVar(lm, txSeq);
txSeq->name = lmCloneString(lm, pred->name);
txSeq->dna = seq;
txSeq->size = txLen;
return txSeq;
}
struct annoRow *aggvIntergenicRow(struct annoGratorGpVar *self, struct variant *variant,
boolean *retRJFilterFailed, struct lm *callerLm)
/* If intergenic variants (no overlapping or nearby genes) are to be included in output,
* make an output row with empty genePred and a gpFx that is empty except for soNumber. */
{
struct annoGrator *gSelf = &(self->grator);
struct annoStreamer *sSelf = &(gSelf->streamer);
char **wordsOut;
lmAllocArray(self->lm, wordsOut, sSelf->numCols);
// Add empty strings for genePred string columns:
int gpColCount = gSelf->mySource->numCols;
int i;
for (i = 0; i < gpColCount; i++)
wordsOut[i] = "";
struct gpFx *intergenicGpFx;
lmAllocVar(self->lm, intergenicGpFx);
intergenicGpFx->allele = firstAltAllele(variant->alleles);
if (isAllNt(intergenicGpFx->allele, strlen(intergenicGpFx->allele)))
touppers(intergenicGpFx->allele);
intergenicGpFx->soNumber = intergenic_variant;
intergenicGpFx->detailType = none;
aggvStringifyGpFx(&wordsOut[gpColCount], intergenicGpFx, self->lm);
boolean rjFail = (retRJFilterFailed && *retRJFilterFailed);
return annoRowFromStringArray(variant->chrom, variant->chromStart, variant->chromEnd, rjFail,
wordsOut, sSelf->numCols, callerLm);
}
struct bbiSummary *bbiSummarySimpleReduce(struct bbiSummary *list, int reduction, struct lm *lm)
/* Do a simple reduction - where among other things the reduction level is an integral
* multiple of the previous reduction level, and the list is sorted. Allocate result out of lm. */
{
struct bbiSummary *newList = NULL, *sum, *newSum = NULL;
for (sum = list; sum != NULL; sum = sum->next)
{
if (newSum == NULL || newSum->chromId != sum->chromId || sum->end > newSum->start + reduction)
{
lmAllocVar(lm, newSum);
*newSum = *sum;
slAddHead(&newList, newSum);
}
else
{
assert(newSum->end < sum->end); // check sorted input assumption
newSum->end = sum->end;
newSum->validCount += sum->validCount;
if (newSum->minVal > sum->minVal) newSum->minVal = sum->minVal;
if (newSum->maxVal < sum->maxVal) newSum->maxVal = sum->maxVal;
newSum->sumData += sum->sumData;
newSum->sumSquares += sum->sumSquares;
}
}
slReverse(&newList);
return newList;
}
struct exonFrames *cdsExonAddFrames(struct cdsExon *exon,
int qStart, int qEnd, char qStrand,
char *tName, int tStart, int tEnd,
char frame, char geneStrand, int cdsOff)
/* allocate a new mafFrames object and link it exon */
{
struct orgGenes *genes = exon->gene->genes;
struct exonFrames *ef;
lmAllocVar(genes->memPool, ef);
ef->exon = exon;
/* fill in query part */
ef->mf.src = genes->srcDb;
ef->srcStart = qStart;
ef->srcEnd = qEnd;
ef->srcStrand = qStrand;
ef->cdsStart = cdsOff;
ef->cdsEnd = cdsOff + (qEnd - qStart);
/* fill in mafFrames part */
ef->mf.chrom = lmCloneString(genes->memPool, tName);
ef->mf.chromStart = tStart;
ef->mf.chromEnd = tEnd;
ef->mf.frame = frame;
ef->mf.strand[0] = geneStrand;
ef->mf.name = exon->gene->name;
ef->mf.prevFramePos = -1;
ef->mf.nextFramePos = -1;
slAddHead(&exon->frames, ef);
exon->gene->numExonFrames++;
return ef;
}
static void addFilteredBedsOnRegion(char *fileName, struct region *region,
char *table, struct asFilter *filter, struct lm *bedLm, struct bed **pBedList,
struct hash *idHash, int *pMaxOut)
/* Add relevant beds in reverse order to pBedList */
{
struct lm *lm = lmInit(0);
struct samAlignment *sam, *samList = bamFetchSamAlignment(fileName, region->chrom,
region->start, region->end, lm);
char *row[SAMALIGNMENT_NUM_COLS];
char numBuf[BAM_NUM_BUF_SIZE];
for (sam = samList; sam != NULL; sam = sam->next)
{
samAlignmentToRow(sam, numBuf, row);
if (asFilterOnRow(filter, row))
{
if ((idHash != NULL) && (hashLookup(idHash, sam->qName) == NULL))
continue;
struct bed *bed;
lmAllocVar(bedLm, bed);
bed->chrom = lmCloneString(bedLm, sam->rName);
bed->chromStart = sam->pos - 1;
bed->chromEnd = bed->chromStart + cigarWidth(sam->cigar, strlen(sam->cigar));
bed->name = lmCloneString(bedLm, sam->qName);
slAddHead(pBedList, bed);
}
(*pMaxOut)--;
if (*pMaxOut <= 0)
break;
}
lmCleanup(&lm);
}
static struct bbiInterval *bigBedCoverageIntervals(struct bbiFile *bbi,
char *chrom, bits32 start, bits32 end, struct lm *lm)
/* Return intervals where the val is the depth of coverage. */
{
/* Get list of overlapping intervals */
struct bigBedInterval *bi, *biList = bigBedIntervalQuery(bbi, chrom, start, end, 0, lm);
if (biList == NULL)
return NULL;
/* Make a range tree that collects coverage. */
struct rbTree *rangeTree = rangeTreeNew();
for (bi = biList; bi != NULL; bi = bi->next)
rangeTreeAddToCoverageDepth(rangeTree, bi->start, bi->end);
struct range *range, *rangeList = rangeTreeList(rangeTree);
/* Convert rangeList to bbiInterval list. */
struct bbiInterval *bwi, *bwiList = NULL;
for (range = rangeList; range != NULL; range = range->next)
{
lmAllocVar(lm, bwi);
bwi->start = range->start;
if (bwi->start < start)
bwi->start = start;
bwi->end = range->end;
if (bwi->end > end)
bwi->end = end;
bwi->val = ptToInt(range->val);
slAddHead(&bwiList, bwi);
}
slReverse(&bwiList);
/* Clean up and go home. */
rangeTreeFree(&rangeTree);
return bwiList;
}
void bitmapToMaskArray(struct hash *bitmapHash, struct hash *tbHash)
/* Translate each bitmap in bitmapHash into an array of mask coordinates
* in the corresponding twoBit in tbHash. Assume tbHash's mask array is
* empty at the start -- we allocate it here. Free bitmap when done. */
{
struct hashCookie cookie = hashFirst(tbHash);
struct hashEl *hel = NULL;
while ((hel = hashNext(&cookie)) != NULL)
{
char *seqName = hel->name;
struct twoBit *tb = (struct twoBit *)(hel->val);
struct hashEl *bHel = hashLookup(bitmapHash, seqName);
Bits *bits;
unsigned start=0, end=0;
assert(tb != NULL);
assert(tb->maskBlockCount == 0);
if (bHel == NULL)
errAbort("Missing bitmap for seq \"%s\"", seqName);
bits = (Bits *)bHel->val;
if (bits != NULL)
{
struct lm *lm = lmInit(0);
struct unsignedRange *rangeList = NULL, *range = NULL;
int i;
for (;;)
{
start = bitFindSet(bits, end, tb->size);
if (start >= tb->size)
break;
end = bitFindClear(bits, start, tb->size);
if (end > start)
{
lmAllocVar(lm, range);
range->start = start;
range->size = (end - start);
slAddHead(&rangeList, range);
}
}
slReverse(&rangeList);
tb->maskBlockCount = slCount(rangeList);
if (tb->maskBlockCount > 0)
{
AllocArray(tb->maskStarts, tb->maskBlockCount);
AllocArray(tb->maskSizes, tb->maskBlockCount);
for (i = 0, range = rangeList; range != NULL;
i++, range = range->next)
{
tb->maskStarts[i] = range->start;
tb->maskSizes[i] = range->size;
}
}
lmCleanup(&lm);
bitFree(&bits);
bHel->val = NULL;
}
}
}
static struct pslRef *pslRefAlloc(struct pslSets *ps)
/* allocate a matches object, either new or from the recycled list */
{
struct pslRef *pr = slPopHead(&ps->refPool);
if (pr == NULL)
lmAllocVar(ps->lm, pr);
return pr;
}
static void addWaysInAndOut(struct rbTree *vertexTree, struct rbTree *edgeTree,
struct lm *lm)
/* Put a bunch of ways in and out of the graph onto the edges. */
{
struct slRef *edgeRef, *edgeRefList = rbTreeItems(edgeTree);
for (edgeRef = edgeRefList; edgeRef != NULL; edgeRef = edgeRef->next)
{
struct edge *edge = edgeRef->val;
struct slRef *inRef, *outRef;
lmAllocVar(lm, inRef);
lmAllocVar(lm, outRef);
inRef->val = outRef->val = edge;
slAddHead(&edge->start->waysOut, outRef);
slAddHead(&edge->end->waysIn, inRef);
}
slFreeList(&edgeRefList);
}
void addInt(struct intList **pList, int val)
/* Add value to int list. */
{
struct intList *el;
lmAllocVar(intLm, el);
el->val = val;
slAddHead(pList, el);
}
struct raFilePos *raFilePosNew(struct lm *lm, char *fileName, int lineIx)
/* Create new raFilePos record. */
{
struct raFilePos *fp;
lmAllocVar(lm, fp);
fp->fileName = fileName;
fp->lineIx = lineIx;
return fp;
}
struct variant *variantNew(char *chrom, unsigned start, unsigned end, unsigned numAlleles,
char *slashSepAlleles, char *refAllele, struct lm *lm)
/* Create a variant from basic information that is easy to extract from most other variant
* formats: coords, allele count, string of slash-separated alleles and reference allele. */
{
struct variant *variant;
// We have a new variant!
lmAllocVar(lm, variant);
variant->chrom = lmCloneString(lm, chrom);
variant->chromStart = start;
variant->chromEnd = end;
variant->numAlleles = numAlleles;
// get the alleles.
char *nextAlleleString = lmCloneString(lm, slashSepAlleles);
int alleleNumber = 0;
for( ; alleleNumber < numAlleles; alleleNumber++)
{
if (nextAlleleString == NULL)
errAbort("number of alleles in /-separated string doesn't match numAlleles");
char *thisAlleleString = nextAlleleString;
// advance pointer to next variant string
// probably there's some kent routine to do this behind the curtain
nextAlleleString = strchr(thisAlleleString, '/');
if (nextAlleleString) // null out '/' and move to next char
{
*nextAlleleString = 0;
nextAlleleString++;
}
boolean isRefAllele = (sameWord(thisAlleleString, refAllele) ||
(isEmpty(refAllele) && sameString(thisAlleleString, "-")));
int alleleStringLength = strlen(thisAlleleString);
if (isDash(thisAlleleString))
{
alleleStringLength = 0;
thisAlleleString[0] = '\0';
}
// we have a new allele!
struct allele *allele;
AllocVar(allele);
slAddHead(&variant->alleles, allele);
allele->variant = variant;
allele->length = alleleStringLength;
allele->sequence = lmCloneString(lm, thisAlleleString);
allele->isReference = isRefAllele;
}
slReverse(&variant->alleles);
return variant;
}
static struct kgEntry *kgEntryAdd(struct spMapper *sm, struct hashEl* kgHel, struct kgPair *kgPair)
/* Add a new kgEntry to a hash chain */
{
struct kgEntry *kgEntry;
lmAllocVar(sm->kgPairMap->lm, kgEntry);
kgEntry->id = kgHel->name;
kgEntry->kgPair = kgPair;
slAddHead((struct kgEntry**)&kgHel->val, kgEntry);
return kgEntry;
}
struct raField *raFieldNew(char *name, char *val, struct lm *lm)
/* Return new raField. */
{
struct raField *field;
lmAllocVar(lm, field);
field->name = lmCloneString(lm, name);
val = emptyForNull(skipLeadingSpaces(val));
field->val = lmCloneString(lm, val);
return field;
}
static struct refChrom *refChromAdd(struct hapRegions *hr, char *chrom)
/* add a refChrom object */
{
struct hashEl *hel;
struct refChrom *refChrom;
lmAllocVar(hr->refMap->lm, refChrom);
hel = hashAdd(hr->refMap, chrom, refChrom);
refChrom->chrom = hel->name;
return refChrom;
}
void getTrfUnsplit(struct sqlConnection *conn, struct hash *chromHash)
/* Return a tree of ranges for simple repeats in all chromosomes,
* from a single query on the whole (unsplit) simpleRepeat table. */
{
struct rbTreeNode **stack = lmAlloc(qLm, 256 * sizeof(stack[0]));
struct rbTree *tree = rbTreeNewDetailed(simpleRangeCmp, qLm, stack);
struct simpleRange *range, *prevRange = NULL;
struct sqlResult *sr;
char **row;
char *prevChrom = NULL;
sr = sqlGetResult(conn, "NOSQLINJ select chrom,chromStart,chromEnd from simpleRepeat"
" order by chrom,chromStart");
while ((row = sqlNextRow(sr)) != NULL)
{
if (prevChrom == NULL)
prevChrom = cloneString(row[0]);
else if (! sameString(prevChrom, row[0]))
{
rbTreeAdd(tree, prevRange);
setTrf(prevChrom, chromHash, tree);
prevRange = NULL;
freeMem(prevChrom);
stack = lmAlloc(qLm, 256 * sizeof(stack[0]));
tree = rbTreeNewDetailed(simpleRangeCmp, qLm, stack);
prevChrom = cloneString(row[0]);
}
lmAllocVar(tree->lm, range);
range->start = sqlUnsigned(row[1]);
range->end = sqlUnsigned(row[2]);
if (prevRange == NULL)
prevRange = range;
else if (overlap(range, prevRange))
{
/* merge r into prevR & discard; prevR gets passed forward. */
if (range->end > prevRange->end)
prevRange->end = range->end;
if (range->start < prevRange->start)
prevRange->start = range->start;
}
else
{
rbTreeAdd(tree, prevRange);
prevRange = range;
}
}
if (prevChrom != NULL)
{
rbTreeAdd(tree, prevRange);
setTrf(prevChrom, chromHash, tree);
freeMem(prevChrom);
}
sqlFreeResult(&sr);
}
struct slPair *tagStanzaAppend(struct tagStorm *tagStorm, struct tagStanza *stanza,
char *tag, char *val)
/* Add tag with given value to stanza */
{
struct lm *lm = tagStorm->lm;
struct slPair *pair;
lmAllocVar(lm, pair);
pair->name = lmCloneString(lm, tag);
pair->val = lmCloneString(lm, val);
slAddTail(&stanza->tagList, pair);
return pair;
}
static struct pslMatches *pslMatchesAlloc(struct pslSets *ps)
/* allocate a matches object, either new or from the recycled list */
{
struct pslMatches *pm = slPopHead(&ps->matchesPool);
if (pm == NULL)
{
lmAllocVar(ps->lm, pm);
lmAllocArray(ps->lm, pm->psls, ps->numSets);
}
pm->numSets = ps->numSets;
return pm;
}
