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 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 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 easyGene *easyGeneCommaIn(char **pS, struct easyGene *ret)
/* Create a easyGene out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new easyGene */
{
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->feat = sqlStringComma(&s);
ret->R = sqlFloatComma(&s);
ret->frame = sqlUnsignedComma(&s);
ret->orf = sqlStringComma(&s);
ret->startCodon = sqlStringComma(&s);
ret->logOdds = sqlFloatComma(&s);
ret->descriptor = sqlStringComma(&s);
ret->swissProt = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->genbank, sizeof(ret->genbank));
*pS = s;
return ret;
}
struct dbRIP *dbRIPCommaIn(char **pS, struct dbRIP *ret)
/* Create a dbRIP out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new dbRIP */
{
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->originalId = sqlStringComma(&s);
ret->forwardPrimer = sqlStringComma(&s);
ret->reversePrimer = sqlStringComma(&s);
ret->polyClass = sqlStringComma(&s);
ret->polyFamily = sqlStringComma(&s);
ret->polySubfamily = sqlStringComma(&s);
ret->polySeq = sqlStringComma(&s);
ret->polySource = sqlStringComma(&s);
ret->reference = sqlStringComma(&s);
ret->ascertainingMethod = sqlStringComma(&s);
ret->remarks = sqlStringComma(&s);
ret->tm = sqlFloatComma(&s);
ret->filledSize = sqlSignedComma(&s);
ret->emptySize = sqlSignedComma(&s);
ret->disease = sqlStringComma(&s);
ret->genoRegion = sqlStringComma(&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 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 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;
int i;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlStringComma(&s);
ret->errFile = sqlStringComma(&s);
ret->outFile = sqlStringComma(&s);
ret->cpuTime = sqlFloatComma(&s);
ret->submitTime = sqlStringComma(&s);
ret->startTime = sqlStringComma(&s);
ret->endTime = sqlStringComma(&s);
ret->retVal = sqlSignedComma(&s);
ret->gotRetVal = 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);
*pS = s;
return ret;
}
struct snoRNAs *snoRNAsCommaIn(char **pS, struct snoRNAs *ret)
/* Create a snoRNAs out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new snoRNAs */
{
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->snoScore = sqlFloatComma(&s);
ret->targetList = sqlStringComma(&s);
ret->orthologs = sqlStringComma(&s);
ret->guideLen = sqlStringComma(&s);
ret->guideStr = sqlStringComma(&s);
ret->guideScore = sqlStringComma(&s);
ret->cBox = sqlStringComma(&s);
ret->dBox = sqlStringComma(&s);
ret->cpBox = sqlStringComma(&s);
ret->dpBox = sqlStringComma(&s);
ret->hmmScore = sqlFloatComma(&s);
ret->snoscanOutput = 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 dgvPlus *dgvPlusCommaIn(char **pS, struct dgvPlus *ret)
/* Create a dgvPlus out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new dgvPlus */
{
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->itemRgb = sqlUnsignedComma(&s);
ret->varType = sqlStringComma(&s);
ret->reference = sqlStringComma(&s);
ret->pubMedId = sqlUnsignedComma(&s);
ret->method = sqlStringComma(&s);
ret->platform = sqlStringComma(&s);
ret->mergedVariants = sqlStringComma(&s);
ret->supportingVariants = sqlStringComma(&s);
ret->sampleSize = sqlUnsignedComma(&s);
ret->observedGains = sqlUnsignedComma(&s);
ret->observedLosses = sqlUnsignedComma(&s);
ret->cohortDescription = sqlStringComma(&s);
ret->genes = sqlStringComma(&s);
ret->samples = sqlStringComma(&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 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 stsMarker *stsMarkerCommaIn(char **pS, struct stsMarker *ret)
/* Create a stsMarker out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new stsMarker */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlSignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->score = sqlUnsignedComma(&s);
ret->identNo = sqlUnsignedComma(&s);
ret->ctgAcc = sqlStringComma(&s);
ret->otherAcc = sqlStringComma(&s);
ret->genethonChrom = sqlStringComma(&s);
ret->genethonPos = sqlSignedComma(&s);
ret->marshfieldChrom = sqlStringComma(&s);
ret->marshfieldPos = sqlSignedComma(&s);
ret->gm99Gb4Chrom = sqlStringComma(&s);
ret->gm99Gb4Pos = sqlSignedComma(&s);
ret->shgcG3Chrom = sqlStringComma(&s);
ret->shgcG3Pos = sqlSignedComma(&s);
ret->wiYacChrom = sqlStringComma(&s);
ret->wiYacPos = sqlSignedComma(&s);
ret->shgcTngChrom = sqlStringComma(&s);
ret->shgcTngPos = sqlSignedComma(&s);
ret->fishChrom = sqlStringComma(&s);
ret->beginBand = sqlStringComma(&s);
ret->endBand = sqlStringComma(&s);
*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 tigrCmrGene *tigrCmrGeneCommaIn(char **pS, struct tigrCmrGene *ret)
/* Create a tigrCmrGene out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new tigrCmrGene */
{
char *s = *pS;
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->tigrCommon = sqlStringComma(&s);
ret->tigrGene = sqlStringComma(&s);
ret->tigrECN = sqlStringComma(&s);
ret->primLocus = sqlStringComma(&s);
ret->tigrLength = sqlUnsignedComma(&s);
ret->tigrPepLength = sqlUnsignedComma(&s);
ret->tigrMainRole = sqlStringComma(&s);
ret->tigrSubRole = sqlStringComma(&s);
ret->swissProt = sqlStringComma(&s);
ret->genbank = sqlStringComma(&s);
ret->tigrMw = sqlFloatComma(&s);
ret->tigrPi = sqlFloatComma(&s);
ret->tigrGc = sqlFloatComma(&s);
ret->goTerm = sqlStringComma(&s);
*pS = s;
return ret;
}
struct orthoAlleles *orthoAllelesCommaIn(char **pS, struct orthoAlleles *ret)
/* Create a orthoAlleles out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new orthoAlleles */
{
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));
sqlFixedStringComma(&s, &(ret->allele1), sizeof(ret->allele1));
ret->allele1Freq = sqlFloatComma(&s);
ret->allele1Count = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->allele2), sizeof(ret->allele2));
ret->allele2Freq = sqlFloatComma(&s);
ret->allele2Count = sqlUnsignedComma(&s);
ret->ortho1Chrom = sqlStringComma(&s);
ret->ortho1ChromStart = sqlUnsignedComma(&s);
ret->ortho1ChromEnd = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->ortho1Strand), sizeof(ret->ortho1Strand));
ret->ortho1State = sqlStringComma(&s);
ret->ortho2Chrom = sqlStringComma(&s);
ret->ortho2ChromStart = sqlUnsignedComma(&s);
ret->ortho2ChromEnd = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->ortho2Strand), sizeof(ret->ortho2Strand));
ret->ortho2State = 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 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 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 gbExtFile *gbExtFileCommaIn(char **pS, struct gbExtFile *ret)
/* Create a gbExtFile out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new gbExtFile */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
ret->path = sqlStringComma(&s);
ret->size = 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;
}
/** Create a coordConv out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new coordConv */
struct coordConv *coordConvCommaIn(char **pS, struct coordConv *ret)
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->version = sqlStringComma(&s);
ret->date = sqlStringComma(&s);
ret->nibDir = sqlStringComma(&s);
ret->optional = sqlStringComma(&s);
*pS = s;
return ret;
}
struct polyASize *polyASizeCommaIn(char **pS, struct polyASize *ret)
/* Create a polyASize out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new polyASize */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->id = sqlStringComma(&s);
ret->seqSize = sqlUnsignedComma(&s);
ret->tailPolyASize = sqlUnsignedComma(&s);
ret->headPolyTSize = sqlUnsignedComma(&s);
*pS = s;
return ret;
}
struct kgColor *kgColorCommaIn(char **pS, struct kgColor *ret)
/* Create a kgColor out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new kgColor */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->kgID = sqlStringComma(&s);
ret->r = sqlUnsignedComma(&s);
ret->g = sqlUnsignedComma(&s);
ret->b = 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 landmarkAttr *landmarkAttrCommaIn(char **pS, struct landmarkAttr *ret)
/* Create a landmarkAttr out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new landmarkAttr */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->landmarkId = sqlUnsignedComma(&s);
ret->linkId = sqlUnsignedComma(&s);
ret->attribute = sqlStringComma(&s);
ret->attrVal = sqlStringComma(&s);
*pS = s;
return ret;
}
struct dvBed *dvBedCommaIn(char **pS, struct dvBed *ret)
/* Create a dvBed out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new dvBed */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
*pS = s;
return ret;
}
struct snp125Exceptions *snp125ExceptionsCommaIn(char **pS, struct snp125Exceptions *ret)
/* Create a snp125Exceptions out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new snp125Exceptions */
{
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->exception = sqlStringComma(&s);
*pS = s;
return ret;
}
struct simpleNucDiff *simpleNucDiffCommaIn(char **pS, struct simpleNucDiff *ret)
/* Create a simpleNucDiff out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new simpleNucDiff */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->tSeq = sqlStringComma(&s);
ret->qSeq = sqlStringComma(&s);
*pS = s;
return ret;
}