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 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 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 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 alleleFreqs *alleleFreqsCommaIn(char **pS, struct alleleFreqs *ret)
/* Create a alleleFreqs out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new alleleFreqs */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
ret->rsId = sqlStringComma(&s);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlSignedComma(&s);
sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));
ret->assembly = sqlStringComma(&s);
ret->center = sqlStringComma(&s);
ret->protLSID = sqlStringComma(&s);
ret->assayLSID = sqlStringComma(&s);
ret->panelLSID = sqlStringComma(&s);
sqlFixedStringComma(&s, &(ret->majAllele), sizeof(ret->majAllele));
ret->majCount = sqlSignedComma(&s);
ret->majFreq = sqlFloatComma(&s);
sqlFixedStringComma(&s, &(ret->minAllele), sizeof(ret->minAllele));
ret->minCount = sqlSignedComma(&s);
ret->minFreq = sqlFloatComma(&s);
ret->total = sqlSignedComma(&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 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 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 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 stanMad *stanMadCommaIn(char **pS, struct stanMad *ret)
/* Create a stanMad out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new stanMad */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->exp = sqlStringComma(&s);
ret->name = sqlStringComma(&s);
ret->type = sqlStringComma(&s);
ret->ch1i = sqlSignedComma(&s);
ret->ch1b = sqlSignedComma(&s);
ret->ch1d = sqlSignedComma(&s);
ret->ch2i = sqlSignedComma(&s);
ret->ch2b = sqlSignedComma(&s);
ret->ch2d = sqlSignedComma(&s);
ret->ch2in = sqlSignedComma(&s);
ret->ch2bn = sqlSignedComma(&s);
ret->ch2dn = sqlSignedComma(&s);
ret->rat1 = sqlFloatComma(&s);
ret->rat2 = sqlFloatComma(&s);
ret->rat1n = sqlFloatComma(&s);
ret->rat2n = sqlFloatComma(&s);
ret->mrat = sqlFloatComma(&s);
ret->crt1 = sqlFloatComma(&s);
ret->crt2 = sqlFloatComma(&s);
ret->regr = sqlFloatComma(&s);
ret->corr = sqlFloatComma(&s);
ret->edge = sqlFloatComma(&s);
ret->fing = sqlSignedComma(&s);
ret->grid = sqlSignedComma(&s);
ret->arow = sqlSignedComma(&s);
ret->row = sqlSignedComma(&s);
ret->acol = sqlSignedComma(&s);
ret->col = sqlSignedComma(&s);
ret->plat = sqlSignedComma(&s);
ret->prow = sqlStringComma(&s);
ret->pcol = sqlSignedComma(&s);
ret->flag = sqlSignedComma(&s);
ret->clid = sqlSignedComma(&s);
ret->spot = sqlSignedComma(&s);
ret->left = sqlSignedComma(&s);
ret->top = sqlSignedComma(&s);
ret->right = sqlSignedComma(&s);
ret->bot = sqlSignedComma(&s);
ret->acc5 = sqlStringComma(&s);
ret->acc3 = 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 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 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 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 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 lowelabArkinOperonScore *lowelabArkinOperonScoreCommaIn(char **pS, struct lowelabArkinOperonScore *ret)
/* Create a lowelabArkinOperonScore out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new lowelabArkinOperonScore */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->gene1 = sqlStringComma(&s);
ret->gene2 = sqlStringComma(&s);
ret->prob = sqlFloatComma(&s);
ret->gnMinus = sqlFloatComma(&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 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 affyAtlas *affyAtlasCommaIn(char **pS, struct affyAtlas *ret)
/* Create a affyAtlas out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new affyAtlas */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->annName = sqlStringComma(&s);
ret->probeSet = sqlStringComma(&s);
ret->signal = sqlFloatComma(&s);
sqlFixedStringComma(&s, ret->detection, sizeof(ret->detection));
ret->pval = sqlFloatComma(&s);
ret->tissue = sqlStringComma(&s);
*pS = s;
return ret;
}
struct recombRateRat *recombRateRatCommaIn(char **pS, struct recombRateRat *ret)
/* Create a recombRateRat out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new recombRateRat */
{
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->shrspAvg = sqlFloatComma(&s);
ret->fhhAvg = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct transMapSrc *transMapSrcCommaIn(char **pS, struct transMapSrc *ret)
/* Create a transMapSrc out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new transMapSrc */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->db, sizeof(ret->db));
ret->id = sqlStringComma(&s);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));
ret->ident = sqlFloatComma(&s);
ret->aligned = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct polyGenotype *polyGenotypeCommaIn(char **pS, struct polyGenotype *ret)
/* Create a polyGenotype out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new polyGenotype */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->ethnicGroup = sqlStringComma(&s);
ret->plusPlus = sqlSignedComma(&s);
ret->plusMinus = sqlSignedComma(&s);
ret->minusMinus = sqlSignedComma(&s);
ret->sampleSize = sqlSignedComma(&s);
ret->alleleFrequency = sqlFloatComma(&s);
ret->unbiasedHeterozygosity = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct genomicSuperDups *genomicSuperDupsCommaIn(char **pS, struct genomicSuperDups *ret)
/* Create a genomicSuperDups out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new genomicSuperDups */
{
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->otherChrom = sqlStringComma(&s);
ret->otherStart = sqlUnsignedComma(&s);
ret->otherEnd = sqlUnsignedComma(&s);
ret->otherSize = sqlUnsignedComma(&s);
ret->uid = sqlUnsignedComma(&s);
ret->posBasesHit = sqlUnsignedComma(&s);
ret->testResult = sqlStringComma(&s);
ret->verdict = sqlStringComma(&s);
ret->chits = sqlStringComma(&s);
ret->ccov = sqlStringComma(&s);
ret->alignfile = sqlStringComma(&s);
ret->alignL = sqlUnsignedComma(&s);
ret->indelN = sqlUnsignedComma(&s);
ret->indelS = sqlUnsignedComma(&s);
ret->alignB = sqlUnsignedComma(&s);
ret->matchB = sqlUnsignedComma(&s);
ret->mismatchB = sqlUnsignedComma(&s);
ret->transitionsB = sqlUnsignedComma(&s);
ret->transversionsB = sqlUnsignedComma(&s);
ret->fracMatch = sqlFloatComma(&s);
ret->fracMatchIndel = sqlFloatComma(&s);
ret->jcK = sqlFloatComma(&s);
ret->k2K = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct pbStamp *pbStampCommaIn(char **pS, struct pbStamp *ret)
/* Create a pbStamp out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new pbStamp */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->stampName, sizeof(ret->stampName));
sqlFixedStringComma(&s, ret->stampTable, sizeof(ret->stampTable));
sqlFixedStringComma(&s, ret->stampTitle, sizeof(ret->stampTitle));
ret->len = sqlSignedComma(&s);
ret->xmin = sqlFloatComma(&s);
ret->xmax = sqlFloatComma(&s);
ret->ymin = sqlFloatComma(&s);
ret->ymax = sqlFloatComma(&s);
ret->stampDesc = sqlStringComma(&s);
*pS = s;
return ret;
}
struct cpgIslandExt *cpgIslandExtCommaIn(char **pS, struct cpgIslandExt *ret)
/* Create a cpgIslandExt out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new cpgIslandExt */
{
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->length = sqlUnsignedComma(&s);
ret->cpgNum = sqlUnsignedComma(&s);
ret->gcNum = sqlUnsignedComma(&s);
ret->perCpg = sqlFloatComma(&s);
ret->perGc = sqlFloatComma(&s);
ret->obsExp = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct stsInfoRat *stsInfoRatCommaIn(char **pS, struct stsInfoRat *ret)
/* Create a stsInfoRat out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new stsInfoRat */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->identNo = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->RGDId = sqlUnsignedComma(&s);
ret->RGDName = sqlStringComma(&s);
ret->UiStsId = sqlUnsignedComma(&s);
ret->nameCount = sqlUnsignedComma(&s);
ret->alias = sqlStringComma(&s);
ret->primer1 = sqlStringComma(&s);
ret->primer2 = sqlStringComma(&s);
ret->distance = sqlStringComma(&s);
ret->sequence = sqlUnsignedComma(&s);
ret->organis = sqlStringComma(&s);
ret->fhhName = sqlStringComma(&s);
ret->fhhChr = sqlStringComma(&s);
ret->fhhGeneticPos = sqlFloatComma(&s);
ret->shrspName = sqlStringComma(&s);
ret->shrspChr = sqlStringComma(&s);
ret->shrspGeneticPos = sqlFloatComma(&s);
ret->rhName = sqlStringComma(&s);
ret->rhChr = sqlStringComma(&s);
ret->rhGeneticPos = sqlFloatComma(&s);
ret->RHLOD = sqlFloatComma(&s);
ret->GeneName = sqlStringComma(&s);
ret->GeneID = sqlStringComma(&s);
ret->clone = sqlStringComma(&s);
*pS = s;
return ret;
}
struct cnpSharpCutoff *cnpSharpCutoffCommaIn(char **pS, struct cnpSharpCutoff *ret)
/* Create a cnpSharpCutoff out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new cnpSharpCutoff */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->sample = sqlStringComma(&s);
ret->batch = sqlUnsignedComma(&s);
ret->value = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct sgdAbundance *sgdAbundanceCommaIn(char **pS, struct sgdAbundance *ret)
/* Create a sgdAbundance out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new sgdAbundance */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->abundance = sqlFloatComma(&s);
ret->error = sqlStringComma(&s);
*pS = s;
return ret;
}
struct geneScore *geneScoreCommaIn(char **pS, struct geneScore *ret)
/* Create a geneScore out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new geneScore */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->chrom = sqlStringComma(&s);
ret->txStart = sqlSignedComma(&s);
ret->score = sqlFloatComma(&s);
*pS = s;
return ret;
}
struct rnaFold *rnaFoldCommaIn(char **pS, struct rnaFold *ret)
/* Create a rnaFold out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new rnaFold */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->seq = sqlStringComma(&s);
ret->fold = sqlStringComma(&s);
ret->energy = sqlFloatComma(&s);
*pS = s;
return ret;
}
