struct wiggle *wiggleCommaIn(char **pS, struct wiggle *ret)
/* Create a wiggle out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new wiggle */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->chrom = sqlStringComma(&s);
ret->chromStart = sqlUnsignedComma(&s);
ret->chromEnd = sqlUnsignedComma(&s);
ret->name = sqlStringComma(&s);
ret->span = sqlUnsignedComma(&s);
ret->count = sqlUnsignedComma(&s);
ret->offset = sqlUnsignedComma(&s);
ret->file = sqlStringComma(&s);
ret->lowerLimit = sqlDoubleComma(&s);
ret->dataRange = sqlDoubleComma(&s);
ret->validCount = sqlUnsignedComma(&s);
ret->sumData = sqlDoubleComma(&s);
ret->sumSquares = sqlDoubleComma(&s);
*pS = s;
return ret;
}
Пример #2
0
struct metaChromGraph *metaChromGraphCommaIn(char **pS, struct metaChromGraph *ret)
/* Create a metaChromGraph out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new metaChromGraph */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->minVal = sqlDoubleComma(&s);
ret->maxVal = sqlDoubleComma(&s);
ret->binaryFile = sqlStringComma(&s);
*pS = s;
return ret;
}
Пример #3
0
struct gtexInfo *gtexInfoCommaIn(char **pS, struct gtexInfo *ret)
/* Create a gtexInfo out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new gtexInfo */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->version = sqlStringComma(&s);
ret->releaseDate = sqlStringComma(&s);
ret->maxScore = sqlDoubleComma(&s);
ret->maxMedianScore = sqlDoubleComma(&s);
*pS = s;
return ret;
}
struct blastTab *blastTabCommaIn(char **pS, struct blastTab *ret)
/* Create a blastTab out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new blastTab */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->query = sqlStringComma(&s);
ret->target = sqlStringComma(&s);
ret->identity = sqlFloatComma(&s);
ret->aliLength = sqlUnsignedComma(&s);
ret->mismatch = sqlUnsignedComma(&s);
ret->gapOpen = sqlUnsignedComma(&s);
ret->qStart = sqlUnsignedComma(&s);
ret->qEnd = sqlUnsignedComma(&s);
ret->tStart = sqlUnsignedComma(&s);
ret->tEnd = sqlUnsignedComma(&s);
ret->eValue = sqlDoubleComma(&s);
ret->bitScore = sqlDoubleComma(&s);
*pS = s;
return ret;
}
Пример #5
0
struct protFeat *protFeatCommaIn(char **pS, struct protFeat *ret)
/* Create a protFeat out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new protFeat */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->protein = sqlStringComma(&s);
ret->start = sqlSignedComma(&s);
ret->end = sqlSignedComma(&s);
ret->feature = sqlStringComma(&s);
ret->score = sqlDoubleComma(&s);
*pS = s;
return ret;
}
Пример #6
0
struct megablastInfo *megablastInfoCommaIn(char **pS, struct megablastInfo *ret)
/* Create a megablastInfo out of a comma separated string.
 * This will fill in ret if non-null, otherwise will
 * return a new megablastInfo */
{
    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->evalue = sqlDoubleComma(&s);
    ret->percentident = sqlUnsignedComma(&s);
    ret->fullname = sqlStringComma(&s);
    ret->taxid = sqlUnsignedComma(&s);
    *pS = s;
    return ret;
}
Пример #7
0
struct chain *chainHeadCommaIn(char **pS, struct chain *ret)
/* Create a chain out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new chain */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->score = sqlDoubleComma(&s);
ret->tName = sqlStringComma(&s);
ret->tSize = sqlUnsignedComma(&s);
ret->tStart = sqlUnsignedComma(&s);
ret->tEnd = sqlUnsignedComma(&s);
ret->qName = sqlStringComma(&s);
ret->qSize = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, &(ret->qStrand), sizeof(ret->qStrand));
ret->qStart = sqlUnsignedComma(&s);
ret->qEnd = sqlUnsignedComma(&s);
ret->id = sqlUnsignedComma(&s);
*pS = s;
return ret;
}
struct cdsPick *cdsPickCommaIn(char **pS, struct cdsPick *ret)
/* Create a cdsPick out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new cdsPick */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->name = sqlStringComma(&s);
ret->start = sqlSignedComma(&s);
ret->end = sqlSignedComma(&s);
ret->source = sqlStringComma(&s);
ret->score = sqlDoubleComma(&s);
ret->startComplete = sqlUnsignedComma(&s);
ret->endComplete = sqlUnsignedComma(&s);
ret->swissProt = sqlStringComma(&s);
ret->uniProt = sqlStringComma(&s);
ret->refProt = sqlStringComma(&s);
ret->refSeq = sqlStringComma(&s);
ret->ccds = sqlStringComma(&s);
*pS = s;
return ret;
}
struct autoTest *autoTestCommaIn(char **pS, struct autoTest *ret)
/* Create a autoTest out of a comma separated string. 
 * This will fill in ret if non-null, otherwise will
 * return a new autoTest */
{
char *s = *pS;

if (ret == NULL)
    AllocVar(ret);
ret->id = sqlUnsignedComma(&s);
sqlFixedStringComma(&s, ret->shortName, sizeof(ret->shortName));
ret->longName = sqlStringComma(&s);
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<3; ++i)
    {
    ret->aliases[i] = sqlStringComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
s = sqlEatChar(s, '{');
if(s[0] != '}')    slSafeAddHead(&ret->threeD, pointCommaIn(&s,NULL));
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
ret->ptCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->pts, ret->ptCount);
for (i=0; i<ret->ptCount; ++i)
    {
    ret->pts[i] = sqlSignedComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->difCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->difs, ret->difCount);
for (i=0; i<ret->difCount; ++i)
    {
    ret->difs[i] = sqlUnsignedComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
for (i=0; i<2; ++i)
    {
    ret->xy[i] = sqlSignedComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->valCount = sqlSignedComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->vals, ret->valCount);
for (i=0; i<ret->valCount; ++i)
    {
    ret->vals[i] = sqlStringComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
ret->dblVal = sqlDoubleComma(&s);
ret->fltVal = sqlFloatComma(&s);
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->dblArray, ret->valCount);
for (i=0; i<ret->valCount; ++i)
    {
    ret->dblArray[i] = sqlDoubleComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
{
int i;
s = sqlEatChar(s, '{');
AllocArray(ret->fltArray, ret->valCount);
for (i=0; i<ret->valCount; ++i)
    {
    ret->fltArray[i] = sqlFloatComma(&s);
    }
s = sqlEatChar(s, '}');
s = sqlEatChar(s, ',');
}
*pS = s;
return ret;
}