struct gtexGeneBed *gtexGeneBedCommaIn(char **pS, struct gtexGeneBed *ret)
/* Create a gtexGeneBed out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new gtexGeneBed */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->geneId = sqlStringComma(&s);
ret->geneType = sqlStringComma(&s);
ret->expCount = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->expScores, ret->expCount);
for (i=0; i<ret->expCount; ++i)
{
ret->expScores[i] = sqlFloatComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct tigrOperon *tigrOperonCommaIn(char **pS, struct tigrOperon *ret)
/* Create a tigrOperon out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new tigrOperon */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->size = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->genes, ret->size);
for (i=0; i<ret->size; ++i)
{
ret->genes[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->info = sqlStringComma(&s);
*pS = s;
return ret;
}
struct splice *spliceLoad(char **row)
/* Load a splice from row fetched with select * from splice
* from database. Dispose of this with spliceFree(). */
{
struct splice *ret;
int sizeOne,i;
char *s;
AllocVar(ret);
ret->vCount = sqlSigned(row[7]);
ret->pathCount = sqlSigned(row[10]);
ret->tName = cloneString(row[0]);
ret->tStart = sqlSigned(row[1]);
ret->tEnd = sqlSigned(row[2]);
ret->name = cloneString(row[3]);
ret->type = sqlSigned(row[4]);
strcpy(ret->strand, row[5]);
ret->agxId = sqlSigned(row[6]);
sqlSignedDynamicArray(row[8], &ret->vPositions, &sizeOne);
assert(sizeOne == ret->vCount);
sqlUbyteDynamicArray(row[9], &ret->vTypes, &sizeOne);
assert(sizeOne == ret->vCount);
s = row[11];
for (i=0; i<ret->pathCount; ++i)
{
s = sqlEatChar(s, '{');
slSafeAddHead(&ret->paths, pathCommaIn(&s, NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->paths);
return ret;
}
struct path *pathCommaIn(char **pS, struct path *ret)
/* Create a path out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new path */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->tName = sqlStringComma(&s);
ret->tStart = sqlSignedComma(&s);
ret->tEnd = sqlSignedComma(&s);
ret->type = sqlSignedComma(&s);
ret->maxVCount = sqlSignedComma(&s);
ret->vCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->vertices, ret->vCount);
for (i=0; i<ret->vCount; ++i)
{
ret->vertices[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->upV = sqlSignedComma(&s);
ret->downV = sqlSignedComma(&s);
ret->bpCount = sqlSignedComma(&s);
*pS = s;
return ret;
}
struct ggMrnaAli *ggMrnaAliLoad(char **row)
/* Load a ggMrnaAli from row fetched with select * from ggMrnaAli
* from database. Dispose of this with ggMrnaAliFree(). */
{
struct ggMrnaAli *ret;
int i;
char *s;
AllocVar(ret);
ret->blockCount = sqlSigned(row[11]);
ret->tName = cloneString(row[0]);
ret->tStart = sqlSigned(row[1]);
ret->tEnd = sqlSigned(row[2]);
strcpy(ret->strand, row[3]);
ret->qName = cloneString(row[4]);
ret->qStart = sqlSigned(row[5]);
ret->qEnd = sqlSigned(row[6]);
ret->baseCount = sqlUnsigned(row[7]);
ret->orientation = sqlSigned(row[8]);
ret->hasIntrons = sqlSigned(row[9]);
ret->milliScore = sqlSigned(row[10]);
s = row[12];
for (i=0; i<ret->blockCount; ++i)
{
s = sqlEatChar(s, '{');
slSafeAddHead(&ret->blocks, ggMrnaBlockCommaIn(&s, NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->blocks);
return ret;
}
struct hgGene *hgGeneCommaIn(char **pS)
/* Create a hgGene out of a comma separated string. */
{
struct hgGene *ret;
char *s = *pS;
int i;
AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->geneFinder = sqlUnsignedComma(&s);
ret->startBac = sqlUnsignedComma(&s);
ret->startPos = sqlUnsignedComma(&s);
ret->endBac = sqlUnsignedComma(&s);
ret->endPos = sqlUnsignedComma(&s);
ret->orientation = sqlSignedComma(&s);
ret->transcriptCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->transcripts, ret->transcriptCount);
for (i=0; i<ret->transcriptCount; ++i)
{
ret->transcripts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct txCluster *txClusterCommaIn(char **pS, struct txCluster *ret)
/* Create a txCluster out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new txCluster */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlSignedComma(&s);
ret->chromEnd = sqlSignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->txCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->txArray, ret->txCount);
for (i=0; i<ret->txCount; ++i)
{
ret->txArray[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct imageClone *imageCloneCommaIn(char **pS, struct imageClone *ret)
/* Create a imageClone out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new imageClone */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
ret->library = sqlStringComma(&s);
ret->plateNum = sqlUnsignedComma(&s);
ret->row = sqlStringComma(&s);
ret->column = sqlUnsignedComma(&s);
ret->libId = sqlUnsignedComma(&s);
ret->organism = sqlStringComma(&s);
ret->numGenbank = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->genbankIds, ret->numGenbank);
for (i=0; i<ret->numGenbank; ++i)
{
ret->genbankIds[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct cutter *cutterCommaIn(char **pS, struct cutter *ret)
/* Create a cutter out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new cutter */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->size = sqlUnsignedComma(&s);
ret->matchSize = sqlUnsignedComma(&s);
ret->seq = sqlStringComma(&s);
ret->cut = sqlUnsignedComma(&s);
ret->overhang = sqlSignedComma(&s);
ret->palindromic = sqlUnsignedComma(&s);
ret->semicolon = sqlUnsignedComma(&s);
ret->numSciz = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->scizs, ret->numSciz);
for (i=0; i<ret->numSciz; ++i)
{
ret->scizs[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->numCompanies = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->companies, ret->numCompanies);
for (i=0; i<ret->numCompanies; ++i)
{
ret->companies[i] = sqlCharComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->numRefs = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->refs, ret->numRefs);
for (i=0; i<ret->numRefs; ++i)
{
ret->refs[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct pslWQueryID *pslWQueryIDCommaIn(char **pS, struct pslWQueryID *ret)
/* Create a pslWQueryID out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new pslWQueryID */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->matches = sqlUnsignedComma(&s);
ret->misMatches = sqlUnsignedComma(&s);
ret->repMatches = sqlUnsignedComma(&s);
ret->nCount = sqlUnsignedComma(&s);
ret->qNumInsert = sqlUnsignedComma(&s);
ret->qBaseInsert = sqlUnsignedComma(&s);
ret->tNumInsert = sqlUnsignedComma(&s);
ret->tBaseInsert = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->qName = sqlStringComma(&s);
ret->qSize = sqlUnsignedComma(&s);
ret->qStart = sqlUnsignedComma(&s);
ret->qEnd = sqlUnsignedComma(&s);
ret->tName = sqlStringComma(&s);
ret->tSize = sqlUnsignedComma(&s);
ret->tStart = sqlUnsignedComma(&s);
ret->tEnd = sqlUnsignedComma(&s);
ret->blockCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->qStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->qStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->tStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->tStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->queryID = sqlStringComma(&s);
*pS = s;
return ret;
}
struct zdobnovSynt *zdobnovSyntCommaIn(char **pS, struct zdobnovSynt *ret)
/* Create a zdobnovSynt out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new zdobnovSynt */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->thickStart = sqlUnsignedComma(&s);
ret->thickEnd = sqlUnsignedComma(&s);
ret->reserved = sqlUnsignedComma(&s);
ret->blockCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->chromStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->chromStarts[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->geneNames, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->geneNames[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct rikenUcscCluster *rikenUcscClusterCommaIn(char **pS, struct rikenUcscCluster *ret)
/* Create a rikenUcscCluster out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new rikenUcscCluster */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->refSeqCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->refSeqs, ret->refSeqCount);
for (i=0; i<ret->refSeqCount; ++i)
{
ret->refSeqs[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->genBankCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->genBanks, ret->genBankCount);
for (i=0; i<ret->genBankCount; ++i)
{
ret->genBanks[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->rikenCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->rikens, ret->rikenCount);
for (i=0; i<ret->rikenCount; ++i)
{
ret->rikens[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct fosEndPairs *fosEndPairsCommaIn(char **pS, struct fosEndPairs *ret)
/* Create a fosEndPairs out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new fosEndPairs */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->bin = sqlSignedComma(&s);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->pslTable = sqlStringComma(&s);
ret->lfCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->lfStarts, ret->lfCount);
for (i=0; i<ret->lfCount; ++i)
{
ret->lfStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->lfSizes, ret->lfCount);
for (i=0; i<ret->lfCount; ++i)
{
ret->lfSizes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->lfNames, ret->lfCount);
for (i=0; i<ret->lfCount; ++i)
{
ret->lfNames[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct jobDb *jobDbCommaIn(char **pS, struct jobDb *ret)
/* Create a jobDb out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new jobDb */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->jobCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<ret->jobCount; ++i)
{
s = sqlEatChar(s, '{');
if(s[0] != '}') slSafeAddHead(&ret->jobList, jobCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->jobList);
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct expData *expDataCommaIn(char **pS, struct expData *ret)
/* Create a expData out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new expData */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->expCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->expScores, ret->expCount);
for (i=0; i<ret->expCount; ++i)
{
ret->expScores[i] = sqlFloatComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct geneBands *geneBandsCommaIn(char **pS, struct geneBands *ret)
/* Create a geneBands out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new geneBands */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->mrnaAcc = sqlStringComma(&s);
ret->count = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->bands, ret->count);
for (i=0; i<ret->count; ++i)
{
ret->bands[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct encodePeak *encodePeakCommaIn(char **pS, struct encodePeak *ret)
/* Create a encodePeak out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new encodePeak */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->signalValue = sqlFloatComma(&s);
ret->pValue = sqlFloatComma(&s);
ret->qValue = sqlFloatComma(&s);
ret->peak = sqlSignedComma(&s);
ret->blockCount = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->blockStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct encodeErgeHssCellLines *encodeErgeHssCellLinesCommaIn(char **pS, struct encodeErgeHssCellLines *ret)
/* Create a encodeErgeHssCellLines out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new encodeErgeHssCellLines */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->thickStart = sqlUnsignedComma(&s);
ret->thickEnd = sqlUnsignedComma(&s);
ret->reserved = sqlUnsignedComma(&s);
ret->blockCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->chromStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->chromStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->Id = sqlStringComma(&s);
ret->color = sqlStringComma(&s);
ret->allLines = sqlStringComma(&s);
*pS = s;
return ret;
}
struct exprBed *exprBedCommaIn(char **pS, struct exprBed *ret)
/* Create a exprBed out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new exprBed */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->size = sqlUnsignedComma(&s);
ret->uniqueAlign = sqlUnsignedComma(&s);
ret->score = sqlUnsignedComma(&s);
ret->hname = sqlStringComma(&s);
ret->numExp = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->hybes, ret->numExp);
for (i=0; i<ret->numExp; ++i)
{
ret->hybes[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->scores, ret->numExp);
for (i=0; i<ret->numExp; ++i)
{
ret->scores[i] = sqlFloatComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct ggMrnaAli *ggMrnaAliCommaIn(char **pS, struct ggMrnaAli *ret)
/* Create a ggMrnaAli out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new ggMrnaAli */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->tName = sqlStringComma(&s);
ret->tStart = sqlSignedComma(&s);
ret->tEnd = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->qName = sqlStringComma(&s);
ret->qStart = sqlSignedComma(&s);
ret->qEnd = sqlSignedComma(&s);
ret->baseCount = sqlUnsignedComma(&s);
ret->orientation = sqlSignedComma(&s);
ret->hasIntrons = sqlSignedComma(&s);
ret->milliScore = sqlSignedComma(&s);
ret->blockCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
for (i=0; i<ret->blockCount; ++i)
{
s = sqlEatChar(s, '{');
slSafeAddHead(&ret->blocks, ggMrnaBlockCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->blocks);
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct job *jobCommaIn(char **pS, struct job *ret)
/* Create a job out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new job */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->command = sqlStringComma(&s);
ret->cpusUsed = sqlFloatComma(&s);
ret->ramUsed = sqlLongLongComma(&s);
ret->checkCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<ret->checkCount; ++i)
{
s = sqlEatChar(s, '{');
if(s[0] != '}') slSafeAddHead(&ret->checkList, checkCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->checkList);
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->submissionCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<ret->submissionCount; ++i)
{
s = sqlEatChar(s, '{');
if(s[0] != '}') slSafeAddHead(&ret->submissionList, submissionCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->submissionList);
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->spec = sqlStringComma(&s);
*pS = s;
return ret;
}
struct mrnaAli *mrnaAliCommaIn(char **pS)
/* Create a mrnaAli out of a comma separated string. */
{
struct mrnaAli *ret;
char *s = *pS;
int i;
AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
ret->readDir = sqlSignedComma(&s);
ret->orientation = sqlSignedComma(&s);
ret->hasIntrons = sqlUnsignedComma(&s);
ret->isEst = sqlUnsignedComma(&s);
ret->score = sqlSignedComma(&s);
ret->qAcc = sqlSignedComma(&s);
ret->qId = sqlUnsignedComma(&s);
ret->qTotalSize = sqlUnsignedComma(&s);
ret->qStart = sqlUnsignedComma(&s);
ret->qEnd = sqlUnsignedComma(&s);
ret->tStartBac = sqlUnsignedComma(&s);
ret->tStartPos = sqlUnsignedComma(&s);
ret->tEndBac = sqlUnsignedComma(&s);
ret->tEndPos = sqlUnsignedComma(&s);
ret->blockCount = sqlUnsignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->qBlockStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->qBlockStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->tBlockBacs, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->tBlockBacs[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->tBlockStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->tBlockStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->startGoods, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->startGoods[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->endGoods, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->endGoods[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct bigPsl *bigPslCommaIn(char **pS, struct bigPsl *ret)
/* Create a bigPsl out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new bigPsl */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->thickStart = sqlUnsignedComma(&s);
ret->thickEnd = sqlUnsignedComma(&s);
ret->reserved = sqlUnsignedComma(&s);
ret->blockCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->chromStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->chromStarts[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->oChromStart = sqlUnsignedComma(&s);
ret->oChromEnd = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->oStrand, sizeof(ret->oStrand));
ret->oChromSize = sqlUnsignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->oChromStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->oChromStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->oSequence = sqlStringComma(&s);
ret->oCDS = sqlStringComma(&s);
ret->oBlock = sqlUnsignedComma(&s);
ret->match = sqlUnsignedComma(&s);
ret->misMatch = sqlUnsignedComma(&s);
ret->repMatch = sqlUnsignedComma(&s);
ret->nCount = sqlUnsignedComma(&s);
*pS = s;
return ret;
}
struct snp125CodingCoordless *snp125CodingCoordlessCommaIn(char **pS, struct snp125CodingCoordless *ret)
/* Create a snp125CodingCoordless out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new snp125CodingCoordless */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->transcript = sqlStringComma(&s);
ret->frame = sqlEnumComma(&s, values_frame, &valhash_frame);
ret->alleleCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->funcCodes, ret->alleleCount);
for (i=0; i<ret->alleleCount; ++i)
{
ret->funcCodes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->alleles, ret->alleleCount);
for (i=0; i<ret->alleleCount; ++i)
{
ret->alleles[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->codons, ret->alleleCount);
for (i=0; i<ret->alleleCount; ++i)
{
ret->codons[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->peptides, ret->alleleCount);
for (i=0; i<ret->alleleCount; ++i)
{
ret->peptides[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct splice *spliceCommaIn(char **pS, struct splice *ret)
/* Create a splice out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new splice */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->tName = sqlStringComma(&s);
ret->tStart = sqlSignedComma(&s);
ret->tEnd = sqlSignedComma(&s);
ret->name = sqlStringComma(&s);
ret->type = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->agxId = sqlSignedComma(&s);
ret->vCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->vPositions, ret->vCount);
for (i=0; i<ret->vCount; ++i)
{
ret->vPositions[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
s = sqlEatChar(s, '{');
AllocArray(ret->vTypes, ret->vCount);
for (i=0; i<ret->vCount; ++i)
{
ret->vTypes[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->pathCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
for (i=0; i<ret->pathCount; ++i)
{
s = sqlEatChar(s, '{');
if(s[0] != '}') slSafeAddHead(&ret->paths, pathCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
slReverse(&ret->paths);
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct altProbe *altProbeCommaIn(char **pS, struct altProbe *ret)
/* Create a altProbe out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new altProbe */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlSignedComma(&s);
ret->chromEnd = sqlSignedComma(&s);
ret->type = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->name = sqlStringComma(&s);
ret->maxCounts = sqlSignedComma(&s);
ret->contProbeCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->contProbeSets, ret->contProbeCount);
for (i=0; i<ret->contProbeCount; ++i)
{
ret->contProbeSets[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->alt1ProbeCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->alt1ProbeSets, ret->alt1ProbeCount);
for (i=0; i<ret->alt1ProbeCount; ++i)
{
ret->alt1ProbeSets[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->alt2ProbeCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->alt2ProbeSets, ret->alt2ProbeCount);
for (i=0; i<ret->alt2ProbeCount; ++i)
{
ret->alt2ProbeSets[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->transcriptCount = sqlSignedComma(&s);
s = sqlEatChar(s, '{');
AllocArray(ret->transcriptNames, ret->transcriptCount);
for (i=0; i<ret->transcriptCount; ++i)
{
ret->transcriptNames[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
*pS = s;
return ret;
}
struct mrnaMisMatch *mrnaMisMatchCommaIn(char **pS, struct mrnaMisMatch *ret)
/* Create a mrnaMisMatch out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new mrnaMisMatch */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
sqlFixedStringComma(&s, &(ret->mrnaBase), sizeof(ret->mrnaBase));
ret->mrnaLoc = sqlSignedComma(&s);
ret->misMatchCount = sqlSignedComma(&s);
ret->bases = sqlStringComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->chroms, ret->misMatchCount);
for (i=0; i<ret->misMatchCount; ++i)
{
ret->chroms[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->tStarts, ret->misMatchCount);
for (i=0; i<ret->misMatchCount; ++i)
{
ret->tStarts[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->strands = sqlStringComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->loci, ret->misMatchCount);
for (i=0; i<ret->misMatchCount; ++i)
{
ret->loci[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->snpCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->snps, ret->snpCount);
for (i=0; i<ret->snpCount; ++i)
{
ret->snps[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct autoTest *autoTestCommaIn(char **pS, struct autoTest *ret)
/* Create a autoTest out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new autoTest */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->shortName, sizeof(ret->shortName));
ret->longName = sqlStringComma(&s);
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<3; ++i)
{
ret->aliases[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
s = sqlEatChar(s, '{');
if(s[0] != '}') slSafeAddHead(&ret->threeD, pointCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->ptCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->pts, ret->ptCount);
for (i=0; i<ret->ptCount; ++i)
{
ret->pts[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->difCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->difs, ret->difCount);
for (i=0; i<ret->difCount; ++i)
{
ret->difs[i] = sqlUnsignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<2; ++i)
{
ret->xy[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->valCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->vals, ret->valCount);
for (i=0; i<ret->valCount; ++i)
{
ret->vals[i] = sqlStringComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->dblVal = sqlDoubleComma(&s);
ret->fltVal = sqlFloatComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->dblArray, ret->valCount);
for (i=0; i<ret->valCount; ++i)
{
ret->dblArray[i] = sqlDoubleComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->fltArray, ret->valCount);
for (i=0; i<ret->valCount; ++i)
{
ret->fltArray[i] = sqlFloatComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}
struct pseudoGeneLink *pseudoGeneLinkCommaIn(char **pS, struct pseudoGeneLink *ret)
/* Create a pseudoGeneLink out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new pseudoGeneLink */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->thickStart = sqlUnsignedComma(&s);
ret->thickEnd = sqlUnsignedComma(&s);
ret->reserved = sqlUnsignedComma(&s);
ret->blockCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->blockSizes, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->blockSizes[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->chromStarts, ret->blockCount);
for (i=0; i<ret->blockCount; ++i)
{
ret->chromStarts[i] = sqlSignedComma(&s);
}
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->trfRatio = sqlFloatComma(&s);
ret->type = sqlStringComma(&s);
ret->axtScore = sqlSignedComma(&s);
ret->gChrom = sqlStringComma(&s);
ret->gStart = sqlSignedComma(&s);
ret->gEnd = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->gStrand, sizeof(ret->gStrand));
ret->exonCount = sqlUnsignedComma(&s);
ret->geneOverlap = sqlUnsignedComma(&s);
ret->polyA = sqlUnsignedComma(&s);
ret->polyAstart = sqlSignedComma(&s);
ret->exonCover = sqlSignedComma(&s);
ret->intronCount = sqlUnsignedComma(&s);
ret->bestAliCount = sqlUnsignedComma(&s);
ret->matches = sqlUnsignedComma(&s);
ret->qSize = sqlUnsignedComma(&s);
ret->qEnd = sqlUnsignedComma(&s);
ret->tReps = sqlUnsignedComma(&s);
ret->overlapRhesus = sqlSignedComma(&s);
ret->overlapMouse = sqlSignedComma(&s);
ret->coverage = sqlUnsignedComma(&s);
ret->label = sqlSignedComma(&s);
ret->milliBad = sqlUnsignedComma(&s);
ret->oldScore = sqlUnsignedComma(&s);
ret->oldIntronCount = sqlSignedComma(&s);
ret->processedIntrons = sqlSignedComma(&s);
ret->conservedSpliceSites = sqlSignedComma(&s);
ret->maxOverlap = sqlSignedComma(&s);
ret->refSeq = sqlStringComma(&s);
ret->rStart = sqlSignedComma(&s);
ret->rEnd = sqlSignedComma(&s);
ret->mgc = sqlStringComma(&s);
ret->mStart = sqlSignedComma(&s);
ret->mEnd = sqlSignedComma(&s);
ret->kgName = sqlStringComma(&s);
ret->kStart = sqlSignedComma(&s);
ret->kEnd = sqlSignedComma(&s);
ret->overName = sqlStringComma(&s);
ret->overStart = sqlSignedComma(&s);
ret->overEnd = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->overStrand, sizeof(ret->overStrand));
ret->overlapDog = sqlSignedComma(&s);
ret->posConf = sqlFloatComma(&s);
ret->polyAlen = sqlUnsignedComma(&s);
*pS = s;
return ret;
}
