自学教程：C++ sqlUnsignedComma函数代码示例

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;}