struct taxonNode *taxonNodeCommaIn(char **pS, struct taxonNode *ret)
/* Create a taxonNode out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new taxonNode */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->taxon = sqlUnsignedComma(&s);
ret->parent = sqlUnsignedComma(&s);
ret->rank = sqlStringComma(&s);
ret->emblcode = sqlStringComma(&s);
ret->division = sqlUnsignedComma(&s);
ret->inheritedDiv = sqlUnsignedComma(&s);
ret->geneticCode = sqlUnsignedComma(&s);
ret->inheritedGC = sqlUnsignedComma(&s);
ret->mitoGeneticCode = sqlUnsignedComma(&s);
ret->inheritedMitoGC = sqlUnsignedComma(&s);
ret->GenBankHidden = sqlUnsignedComma(&s);
ret->notSequenced = sqlUnsignedComma(&s);
ret->comments = sqlStringComma(&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 recombRate *recombRateCommaIn(char **pS, struct recombRate *ret)
/* Create a recombRate out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new recombRate */
{
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->decodeAvg = sqlFloatComma(&s);
ret->decodeFemale = sqlFloatComma(&s);
ret->decodeMale = sqlFloatComma(&s);
ret->marshfieldAvg = sqlFloatComma(&s);
ret->marshfieldFemale = sqlFloatComma(&s);
ret->marshfieldMale = sqlFloatComma(&s);
ret->genethonAvg = sqlFloatComma(&s);
ret->genethonFemale = sqlFloatComma(&s);
ret->genethonMale = sqlFloatComma(&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 rmskOut2 *rmskOut2CommaIn(char **pS, struct rmskOut2 *ret)
/* Create a rmskOut2 out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new rmskOut2 */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->swScore = sqlUnsignedComma(&s);
ret->milliDiv = sqlUnsignedComma(&s);
ret->milliDel = sqlUnsignedComma(&s);
ret->milliIns = sqlUnsignedComma(&s);
ret->genoName = sqlStringComma(&s);
ret->genoStart = sqlUnsignedComma(&s);
ret->genoEnd = sqlUnsignedComma(&s);
ret->genoLeft = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
ret->repName = sqlStringComma(&s);
ret->repClass = sqlStringComma(&s);
ret->repFamily = sqlStringComma(&s);
ret->repStart = sqlSignedComma(&s);
ret->repEnd = sqlUnsignedComma(&s);
ret->repLeft = sqlSignedComma(&s);
ret->id = sqlUnsignedComma(&s);
*pS = s;
return ret;
}
struct hapmapAllelesCombined *hapmapAllelesCombinedCommaIn(char **pS, struct hapmapAllelesCombined *ret)
/* Create a hapmapAllelesCombined out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new hapmapAllelesCombined */
{
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->observed = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->allele1, sizeof(ret->allele1));
ret->allele1CountCEU = sqlUnsignedComma(&s);
ret->allele1CountCHB = sqlUnsignedComma(&s);
ret->allele1CountJPT = sqlUnsignedComma(&s);
ret->allele1CountYRI = sqlUnsignedComma(&s);
ret->allele2 = sqlStringComma(&s);
ret->allele2CountCEU = sqlUnsignedComma(&s);
ret->allele2CountCHB = sqlUnsignedComma(&s);
ret->allele2CountJPT = sqlUnsignedComma(&s);
ret->allele2CountYRI = sqlUnsignedComma(&s);
ret->heteroCountCEU = sqlUnsignedComma(&s);
ret->heteroCountCHB = sqlUnsignedComma(&s);
ret->heteroCountJPT = sqlUnsignedComma(&s);
ret->heteroCountYRI = sqlUnsignedComma(&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 encodeStanfordPromoters *encodeStanfordPromotersCommaIn(char **pS, struct encodeStanfordPromoters *ret)
/* Create a encodeStanfordPromoters out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new encodeStanfordPromoters */
{
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->geneModel = sqlStringComma(&s);
ret->description = sqlStringComma(&s);
ret->lucA = sqlSignedComma(&s);
ret->renA = sqlSignedComma(&s);
ret->lucB = sqlSignedComma(&s);
ret->renB = sqlSignedComma(&s);
ret->avgRatio = sqlFloatComma(&s);
ret->normRatio = sqlFloatComma(&s);
ret->normLog2Ratio = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct submission *submissionCommaIn(char **pS, struct submission *ret)
/* Create a submission out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new submission */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlStringComma(&s);
ret->host = sqlStringComma(&s);
ret->cpuTime = sqlFloatComma(&s);
ret->submitTime = sqlUnsignedComma(&s);
ret->startTime = sqlUnsignedComma(&s);
ret->endTime = sqlUnsignedComma(&s);
ret->status = sqlSignedComma(&s);
ret->gotStatus = sqlUnsignedComma(&s);
ret->submitError = sqlUnsignedComma(&s);
ret->inQueue = sqlUnsignedComma(&s);
ret->queueError = sqlUnsignedComma(&s);
ret->trackingError = sqlUnsignedComma(&s);
ret->running = sqlUnsignedComma(&s);
ret->crashed = sqlUnsignedComma(&s);
ret->slow = sqlUnsignedComma(&s);
ret->hung = sqlUnsignedComma(&s);
ret->ranOk = sqlUnsignedComma(&s);
ret->errFile = sqlStringComma(&s);
*pS = s;
return ret;
}
struct encodeHapMapAlleleFreq *encodeHapMapAlleleFreqCommaIn(char **pS, struct encodeHapMapAlleleFreq *ret)
/* Create a encodeHapMapAlleleFreq out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new encodeHapMapAlleleFreq */
{
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->center = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->refAllele, sizeof(ret->refAllele));
sqlFixedStringComma(&s, ret->otherAllele, sizeof(ret->otherAllele));
ret->refAlleleFreq = sqlFloatComma(&s);
ret->otherAlleleFreq = sqlFloatComma(&s);
ret->minorAlleleFreq = sqlFloatComma(&s);
ret->totalCount = sqlUnsignedComma(&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 codeBlastScore *codeBlastScoreCommaIn(char **pS, struct codeBlastScore *ret)
/* Create a codeBlastScore out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new codeBlastScore */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->qName = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->code, sizeof(ret->code));
ret->evalue = sqlStringComma(&s);
ret->GI = sqlUnsignedComma(&s);
ret->PI = sqlFloatComma(&s);
ret->length = sqlUnsignedComma(&s);
ret->gap = sqlUnsignedComma(&s);
ret->score = sqlUnsignedComma(&s);
ret->seqstart = sqlUnsignedComma(&s);
ret->seqend = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->species, sizeof(ret->species));
sqlFixedStringComma(&s, ret->product, sizeof(ret->product));
sqlFixedStringComma(&s, ret->name, sizeof(ret->name));
*pS = s;
return ret;
}
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 jaxQTL2 *jaxQTL2CommaIn(char **pS, struct jaxQTL2 *ret)
/* Create a jaxQTL2 out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new jaxQTL2 */
{
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->marker = sqlStringComma(&s);
ret->mgiID = sqlStringComma(&s);
ret->description = sqlStringComma(&s);
ret->cMscore = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct cnpSharp *cnpSharpCommaIn(char **pS, struct cnpSharp *ret)
/* Create a cnpSharp out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new cnpSharp */
{
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->variationType = sqlStringComma(&s);
ret->cytoName = sqlStringComma(&s);
ret->cytoStrain = sqlStringComma(&s);
ret->dupPercent = sqlFloatComma(&s);
ret->repeatsPercent = sqlFloatComma(&s);
ret->LINEpercent = sqlFloatComma(&s);
ret->SINEpercent = sqlFloatComma(&s);
ret->LTRpercent = sqlFloatComma(&s);
ret->DNApercent = sqlFloatComma(&s);
ret->diseaseSpotsPercent = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct wiggle *wiggleCommaIn(char **pS, struct wiggle *ret)
/* Create a wiggle out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new wiggle */
{
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->span = sqlUnsignedComma(&s);
ret->count = sqlUnsignedComma(&s);
ret->offset = sqlUnsignedComma(&s);
ret->file = sqlStringComma(&s);
ret->lowerLimit = sqlDoubleComma(&s);
ret->dataRange = sqlDoubleComma(&s);
ret->validCount = sqlUnsignedComma(&s);
ret->sumData = sqlDoubleComma(&s);
ret->sumSquares = sqlDoubleComma(&s);
*pS = s;
return ret;
}
struct simpleRepeat *simpleRepeatCommaIn(char **pS, struct simpleRepeat *ret)
/* Create a simpleRepeat out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new simpleRepeat */
{
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->period = sqlUnsignedComma(&s);
ret->copyNum = sqlFloatComma(&s);
ret->consensusSize = sqlUnsignedComma(&s);
ret->perMatch = sqlUnsignedComma(&s);
ret->perIndel = sqlUnsignedComma(&s);
ret->score = sqlUnsignedComma(&s);
ret->A = sqlUnsignedComma(&s);
ret->C = sqlUnsignedComma(&s);
ret->G = sqlUnsignedComma(&s);
ret->T = sqlUnsignedComma(&s);
ret->entropy = sqlFloatComma(&s);
ret->sequence = sqlStringComma(&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 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 pgSiftPred *pgSiftPredCommaIn(char **pS, struct pgSiftPred *ret)
/* Create a pgSiftPred out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new pgSiftPred */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = needMem(sizeof(unsigned));
*(ret->chromStart) = sqlUnsignedComma(&s);
ret->chromEnd = needMem(sizeof(unsigned));
*(ret->chromEnd) = sqlUnsignedComma(&s);
ret->prediction = sqlStringComma(&s);
ret->geneId = sqlStringComma(&s);
ret->geneName = sqlStringComma(&s);
ret->geneDesc = sqlStringComma(&s);
ret->protFamDesc = sqlStringComma(&s);
ret->omimDisease = sqlStringComma(&s);
ret->aveAlleleFreq = sqlStringComma(&s);
ret->ceuAlleleFreq = sqlStringComma(&s);
*pS = s;
return ret;
}
struct tableStatus *tableStatusCommaIn(char **pS, struct tableStatus *ret)
/* Create a tableStatus out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new tableStatus */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->type = sqlStringComma(&s);
ret->rowFormat = sqlStringComma(&s);
ret->rows = sqlUnsignedComma(&s);
ret->aveRowLength = sqlUnsignedComma(&s);
ret->dataLength = sqlLongLongComma(&s);
ret->maxDataLength = sqlLongLongComma(&s);
ret->indexLength = sqlLongLongComma(&s);
ret->dataFree = sqlLongLongComma(&s);
ret->autoIncrement = sqlStringComma(&s);
ret->createTime = sqlStringComma(&s);
ret->updateTime = sqlStringComma(&s);
ret->checkTime = sqlStringComma(&s);
ret->createOptions = sqlStringComma(&s);
ret->comment = sqlStringComma(&s);
*pS = s;
return ret;
}
struct cdsSpec *cdsSpecCommaIn(char **pS, struct cdsSpec *ret)
/* Create a cdsSpec out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new cdsSpec */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlStringComma(&s);
ret->cds = sqlStringComma(&s);
*pS = s;
return ret;
}
struct transRegCodeCondition *transRegCodeConditionCommaIn(char **pS, struct transRegCodeCondition *ret)
/* Create a transRegCodeCondition out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new transRegCodeCondition */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->growthCondition = sqlStringComma(&s);
*pS = s;
return ret;
}
struct kgAlias *kgAliasCommaIn(char **pS, struct kgAlias *ret)
/* Create a kgAlias out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new kgAlias */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->kgID = sqlStringComma(&s);
ret->alias = sqlStringComma(&s);
*pS = s;
return ret;
}
struct pepPred *pepPredCommaIn(char **pS, struct pepPred *ret)
/* Create a pepPred out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new pepPred */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->seq = sqlStringComma(&s);
*pS = s;
return ret;
}
struct fbSynonym *fbSynonymCommaIn(char **pS, struct fbSynonym *ret)
/* Create a fbSynonym out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new fbSynonym */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->geneId = sqlStringComma(&s);
ret->name = sqlStringComma(&s);
*pS = s;
return ret;
}
struct geneTree *geneTreeCommaIn(char **pS, struct geneTree *ret)
/* Create a geneTree out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new geneTree */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->tree = sqlStringComma(&s);
*pS = s;
return ret;
}
struct wgEncodeGencodePdb *wgEncodeGencodePdbCommaIn(char **pS, struct wgEncodeGencodePdb *ret)
/* Create a wgEncodeGencodePdb out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new wgEncodeGencodePdb */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->transcriptId = sqlStringComma(&s);
ret->pdbId = sqlStringComma(&s);
*pS = s;
return ret;
}
struct sangerGeneToWBGeneID *sangerGeneToWBGeneIDCommaIn(char **pS, struct sangerGeneToWBGeneID *ret)
/* Create a sangerGeneToWBGeneID out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new sangerGeneToWBGeneID */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->sangerGene = sqlStringComma(&s);
ret->WBGeneID = sqlStringComma(&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;
}
