struct rmskOut *rmskOutCommaIn(char **pS, struct rmskOut *ret)
/* Create a rmskOut out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new rmskOut */
{
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 = sqlSignedComma(&s);
ret->repLeft = sqlSignedComma(&s);
sqlFixedStringComma(&s, ret->id, sizeof(ret->id));
*pS = s;
return ret;
}
struct hapmapPrimateAlleles *hapmapPrimateAllelesCommaIn(char **pS, struct hapmapPrimateAlleles *ret)
/* Create a hapmapPrimateAlleles out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new hapmapPrimateAlleles */
{
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->refAllele), sizeof(ret->refAllele));
sqlFixedStringComma(&s, &(ret->otherAllele), sizeof(ret->otherAllele));
ret->chimpChrom = sqlStringComma(&s);
ret->chimpPos = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->chimpStrand), sizeof(ret->chimpStrand));
ret->chimpAllele = sqlStringComma(&s);
ret->chimpQual = sqlUnsignedComma(&s);
ret->rhesusChrom = sqlStringComma(&s);
ret->rhesusPos = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->rhesusStrand), sizeof(ret->rhesusStrand));
ret->rhesusAllele = sqlStringComma(&s);
ret->rhesusQual = sqlUnsignedComma(&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 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 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 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 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 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 sangInsert *sangInsertCommaIn(char **pS, struct sangInsert *ret)
/* Create a sangInsert out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new sangInsert */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->id, sizeof(ret->id));
sqlFixedStringComma(&s, ret->name, sizeof(ret->name));
*pS = s;
return ret;
}
struct ccdsNotes *ccdsNotesCommaIn(char **pS, struct ccdsNotes *ret)
/* Create a ccdsNotes out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new ccdsNotes */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->ccds, sizeof(ret->ccds));
sqlFixedStringComma(&s, ret->createDate, sizeof(ret->createDate));
ret->note = 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 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 dgv *dgvCommaIn(char **pS, struct dgv *ret)
/* Create a dgv out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new dgv */
{
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->landmark = sqlStringComma(&s);
ret->varType = sqlStringComma(&s);
ret->reference = sqlStringComma(&s);
ret->pubMedId = sqlUnsignedComma(&s);
ret->method = sqlStringComma(&s);
ret->sample = 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 MGIid *MGIidCommaIn(char **pS, struct MGIid *ret)
/* Create a MGIid out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new MGIid */
{
char *s = *pS;
int i;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->LLid, sizeof(ret->LLid));
sqlFixedStringComma(&s, ret->MGIid, sizeof(ret->MGIid));
sqlFixedStringComma(&s, ret->symbol, sizeof(ret->symbol));
*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 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 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 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 tfbsConsFactors *tfbsConsFactorsCommaIn(char **pS, struct tfbsConsFactors *ret)
/* Create a tfbsConsFactors out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new tfbsConsFactors */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->ac = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->species, sizeof(ret->species));
sqlFixedStringComma(&s, ret->factor, sizeof(ret->factor));
sqlFixedStringComma(&s, ret->id, sizeof(ret->id));
*pS = s;
return ret;
}
struct ccdsInfo *ccdsInfoCommaIn(char **pS, struct ccdsInfo *ret)
/* Create a ccdsInfo out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new ccdsInfo */
{
char *s = *pS;
char srcDbBuf[2];
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->ccds, sizeof(ret->ccds));
sqlFixedStringComma(&s, srcDbBuf, sizeof(srcDbBuf));
sqlFixedStringComma(&s, ret->mrnaAcc, sizeof(ret->mrnaAcc));
ret->srcDb = parseSrcDb(srcDbBuf, ret->mrnaAcc);
sqlFixedStringComma(&s, ret->protAcc, sizeof(ret->protAcc));
*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 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 uniref *unirefCommaIn(char **pS, struct uniref *ret)
/* Create a uniref out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new uniref */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
sqlFixedStringComma(&s, ret->entryId, sizeof(ret->entryId));
sqlFixedStringComma(&s, ret->type, sizeof(ret->type));
sqlFixedStringComma(&s, ret->upId, sizeof(ret->upId));
sqlFixedStringComma(&s, ret->upAcc, sizeof(ret->upAcc));
ret->org = sqlStringComma(&s);
ret->tax = sqlSignedComma(&s);
ret->len = sqlSignedComma(&s);
*pS = s;
return ret;
}
struct mafSummary *mafSummaryCommaIn(char **pS, struct mafSummary *ret)
/* Create a mafSummary out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new mafSummary */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->src = sqlStringComma(&s);
ret->score = sqlFloatComma(&s);
sqlFixedStringComma(&s, ret->leftStatus, sizeof(ret->leftStatus));
sqlFixedStringComma(&s, ret->rightStatus, sizeof(ret->rightStatus));
*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 affy10KDetails *affy10KDetailsCommaIn(char **pS, struct affy10KDetails *ret)
/* Create a affy10KDetails out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new affy10KDetails */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->affyId = sqlStringComma(&s);
ret->rsId = sqlStringComma(&s);
ret->tscId = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->baseA, sizeof(ret->baseA));
sqlFixedStringComma(&s, ret->baseB, sizeof(ret->baseB));
sqlFixedStringComma(&s, ret->sequenceA, sizeof(ret->sequenceA));
sqlFixedStringComma(&s, ret->sequenceB, sizeof(ret->sequenceB));
sqlFixedStringComma(&s, ret->enzyme, sizeof(ret->enzyme));
*pS = s;
return ret;
}
struct gsSeqInfo *gsSeqInfoCommaIn(char **pS, struct gsSeqInfo *ret)
/* Create a gsSeqInfo out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new gsSeqInfo */
{
char *s = *pS;
if (ret == NULL)
AllocVar(ret);
ret->acc = sqlStringComma(&s);
sqlFixedStringComma(&s, ret->gi, sizeof(ret->gi));
ret->size = sqlUnsignedComma(&s);
ret->phase = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->draft, sizeof(ret->draft));
ret->chrom = sqlStringComma(&s);
ret->lab = sqlStringComma(&s);
ret->cloneName = sqlStringComma(&s);
*pS = s;
return ret;
}
struct txEdgeBed *txEdgeBedCommaIn(char **pS, struct txEdgeBed *ret)
/* Create a txEdgeBed out of a comma separated string.
* This will fill in ret if non-null, otherwise will
* return a new txEdgeBed */
{
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));
sqlFixedStringComma(&s, ret->startType, sizeof(ret->startType));
ret->type = sqlEnumComma(&s, values_type, &valhash_type);
sqlFixedStringComma(&s, ret->endType, sizeof(ret->endType));
*pS = s;
return ret;
}
