struct meta *metaNextStanza(struct lineFile *lf)
/* Return next stanza in a meta file. Does not set parent/child/next pointers.
* Returns NULL at end of file. Does a little error checking, making sure
* that indentation level is consistent across all lines of stanza. Returns
* indentation level. */
{
/* See if anything left in file, and if not return. */
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
/* Allocate return structure and vars to help parse. */
struct meta *meta;
AllocVar(meta);
struct dyString *dy = dyStringNew(256);
char *tag,*val;
/* Loop to get all tags in stanza. */
boolean firstTime = TRUE;
int initialIndent = 0;
for (;;)
{
dyStringClear(dy);
if (!raNextTagVal(lf, &tag, &val, dy))
break;
/* Make tag/val and add it to list. */
struct metaTagVal *mtv;
AllocVar(mtv);
mtv->tag = cloneString(tag);
mtv->val = cloneString(val);
slAddHead(&meta->tagList, mtv);
/* Check indentation. */
int indent = countLeadingSpacesDetabbing(dy->string, 8);
if (firstTime)
{
initialIndent = indent;
firstTime = FALSE;
}
else
{
if (indent != initialIndent)
{
warn("Error line %d of %s\n", lf->lineIx, lf->fileName);
warn("Indentation level %d doesn't match level %d at start of stanza.",
indent, initialIndent);
if (strchr(dy->string, '\t'))
warn("There are tabs in the indentation, be sure tab stop is set to 8 spaces.");
noWarnAbort();
}
}
}
slReverse(&meta->tagList);
/* Set up remaining fields and return. */
assert(meta->tagList != NULL);
meta->name = meta->tagList->val;
meta->indent = initialIndent;
return meta;
}
struct slPair *raNextStanzAsPairs(struct lineFile *lf)
// Return ra stanza as an slPair list instead of a hash. Handy to preserve the
// order. Will ignore '#' comments and joins continued lines (ending in '\').
{
struct slPair *list = NULL;
char *key, *val;
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
while (raNextTagVal(lf, &key, &val, NULL))
{
slPairAdd(&list, key, cloneString(val)); // key gets cloned by slPairAdd
}
slReverse(&list);
return list;
}
struct hash *raNextStanza(struct lineFile *lf)
// Return a hash containing next record.
// Will ignore '#' comments and joins continued lines (ending in '\').
// Returns NULL at end of file. freeHash this when done.
// Note this will free the hash keys and values as well,
// so you'll have to cloneMem them if you want them for later.
{
struct hash *hash = NULL;
char *key, *val;
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
while (raNextTagVal(lf, &key, &val, NULL))
{
if (hash == NULL)
hash = newHash(7);
hashAdd(hash, key, lmCloneString(hash->lm, val));
}
return hash;
}
static struct raRecord *readRecordsFromFile(struct raFile *file, struct dyString *dy, struct lm *lm)
/* Read all the records in a file and return as a list. The dy parameter returns the
* last bits of the file (after the last record). */
{
char *fileName = file->name;
struct raRecord *r, *rList = NULL;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
while (raSkipLeadingEmptyLines(lf, dy))
{
/* Create a tag structure in local memory. */
lmAllocVar(lm, r);
r->startLineIx = lf->lineIx;
char *name, *val;
while (raNextTagVal(lf, &name, &val, dy))
{
struct raTag *tag;
lmAllocVar(lm, tag);
tag->name = lmCloneString(lm, name);
tag->val = lmCloneString(lm, val);
tag->text = lmCloneString(lm, dy->string);
if (sameString(name, glKeyField))
r->key = lmCloneFirstWord(lm, tag->val);
slAddHead(&r->tagList, tag);
dyStringClear(dy);
}
if (dy->stringSize > 0)
{
r->endComments = lmCloneString(lm, dy->string);
}
slReverse(&r->tagList);
r->endLineIx = lf->lineIx;
r->file = file;
slAddHead(&rList, r);
}
lineFileClose(&lf);
slReverse(&rList);
return rList;
}
struct edwFastqFile *edwFastqFileFromNextRa(struct lineFile *lf, struct raToStructReader *reader)
/* Return next stanza put into an edwFastqFile. */
{
enum fields
{
readCountField,
baseCountField,
readSizeMeanField,
readSizeStdField,
readSizeMinField,
readSizeMaxField,
qualMeanField,
qualStdField,
qualMinField,
qualMaxField,
qualTypeField,
qualZeroField,
atRatioField,
aRatioField,
cRatioField,
gRatioField,
tRatioField,
nRatioField,
posCountField,
qualPosField,
aAtPosField,
cAtPosField,
gAtPosField,
tAtPosField,
nAtPosField,
};
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
struct edwFastqFile *el;
AllocVar(el);
bool *fieldsObserved = reader->fieldsObserved;
bzero(fieldsObserved, reader->fieldCount);
char *tag, *val;
while (raNextTagVal(lf, &tag, &val, NULL))
{
struct hashEl *hel = hashLookup(reader->fieldIds, tag);
if (hel != NULL)
{
int id = ptToInt(hel->val);
if (fieldsObserved[id])
errAbort("Duplicate tag %s line %d of %s\n", tag, lf->lineIx, lf->fileName);
fieldsObserved[id] = TRUE;
switch (id)
{
case readCountField:
{
el->readCount = sqlLongLong(val);
break;
}
case baseCountField:
{
el->baseCount = sqlLongLong(val);
break;
}
case readSizeMeanField:
{
el->readSizeMean = sqlDouble(val);
break;
}
case readSizeStdField:
{
el->readSizeStd = sqlDouble(val);
break;
}
case readSizeMinField:
{
el->readSizeMin = sqlSigned(val);
break;
}
case readSizeMaxField:
{
el->readSizeMax = sqlSigned(val);
break;
}
case qualMeanField:
{
el->qualMean = sqlDouble(val);
break;
}
case qualStdField:
{
el->qualStd = sqlDouble(val);
break;
}
case qualMinField:
{
el->qualMin = sqlDouble(val);
break;
}
case qualMaxField:
{
el->qualMax = sqlDouble(val);
break;
}
case qualTypeField:
{
el->qualType = cloneString(val);
break;
}
case qualZeroField:
{
el->qualZero = sqlSigned(val);
break;
}
case atRatioField:
{
el->atRatio = sqlDouble(val);
break;
}
case aRatioField:
{
el->aRatio = sqlDouble(val);
break;
}
case cRatioField:
{
el->cRatio = sqlDouble(val);
break;
}
case gRatioField:
{
el->gRatio = sqlDouble(val);
break;
}
case tRatioField:
{
el->tRatio = sqlDouble(val);
break;
}
case nRatioField:
{
el->nRatio = sqlDouble(val);
break;
}
case posCountField:
{
int arraySize = sqlSigned(val);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "posCount");
break;
}
case qualPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->qualPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "qualPos");
break;
}
case aAtPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->aAtPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "aAtPos");
break;
}
case cAtPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->cAtPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "cAtPos");
break;
}
case gAtPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->gAtPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "gAtPos");
break;
}
case tAtPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->tAtPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "tAtPos");
break;
}
case nAtPosField:
{
int arraySize;
sqlDoubleDynamicArray(val, &el->nAtPos, &arraySize);
raToStructArraySignedSizer(lf, arraySize, &el->posCount, "nAtPos");
break;
}
default:
internalErr();
break;
}
}
}
raToStructReaderCheckRequiredFields(reader, lf);
return el;
}
struct edwQaWigSpot *edwQaWigSpotFromNextRa(struct lineFile *lf, struct raToStructReader *reader)
/* Return next stanza put into an edwQaWigSpot. */
{
enum fields
{
spotRatioField,
enrichmentField,
basesInGenomeField,
basesInSpotsField,
sumSignalField,
spotSumSignalField,
};
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
struct edwQaWigSpot *el;
AllocVar(el);
bool *fieldsObserved = reader->fieldsObserved;
bzero(fieldsObserved, reader->fieldCount);
char *tag, *val;
while (raNextTagVal(lf, &tag, &val, NULL))
{
struct hashEl *hel = hashLookup(reader->fieldIds, tag);
if (hel != NULL)
{
int id = ptToInt(hel->val);
if (fieldsObserved[id])
errAbort("Duplicate tag %s line %d of %s\n", tag, lf->lineIx, lf->fileName);
fieldsObserved[id] = TRUE;
switch (id)
{
case spotRatioField:
{
el->spotRatio = sqlDouble(val);
break;
}
case enrichmentField:
{
el->enrichment = sqlDouble(val);
break;
}
case basesInGenomeField:
{
el->basesInGenome = sqlLongLong(val);
break;
}
case basesInSpotsField:
{
el->basesInSpots = sqlLongLong(val);
break;
}
case sumSignalField:
{
el->sumSignal = sqlDouble(val);
break;
}
case spotSumSignalField:
{
el->spotSumSignal = sqlDouble(val);
break;
}
default:
internalErr();
break;
}
}
}
raToStructReaderCheckRequiredFields(reader, lf);
return el;
}
struct cdwBamFile *cdwBamFileFromNextRa(struct lineFile *lf, struct raToStructReader *reader)
/* Return next stanza put into an cdwBamFile. */
{
enum fields
{
isPairedField,
isSortedByTargetField,
readCountField,
readBaseCountField,
mappedCountField,
uniqueMappedCountField,
readSizeMeanField,
readSizeStdField,
readSizeMinField,
readSizeMaxField,
u4mReadCountField,
u4mUniquePosField,
u4mUniqueRatioField,
targetBaseCountField,
targetSeqCountField,
};
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
struct cdwBamFile *el;
AllocVar(el);
bool *fieldsObserved = reader->fieldsObserved;
bzero(fieldsObserved, reader->fieldCount);
char *tag, *val;
while (raNextTagVal(lf, &tag, &val, NULL))
{
struct hashEl *hel = hashLookup(reader->fieldIds, tag);
if (hel != NULL)
{
int id = ptToInt(hel->val);
if (fieldsObserved[id])
errAbort("Duplicate tag %s line %d of %s\n", tag, lf->lineIx, lf->fileName);
fieldsObserved[id] = TRUE;
switch (id)
{
case isPairedField:
{
el->isPaired = sqlSigned(val);
break;
}
case isSortedByTargetField:
{
el->isSortedByTarget = sqlSigned(val);
break;
}
case readCountField:
{
el->readCount = sqlLongLong(val);
break;
}
case readBaseCountField:
{
el->readBaseCount = sqlLongLong(val);
break;
}
case mappedCountField:
{
el->mappedCount = sqlLongLong(val);
break;
}
case uniqueMappedCountField:
{
el->uniqueMappedCount = sqlLongLong(val);
break;
}
case readSizeMeanField:
{
el->readSizeMean = sqlDouble(val);
break;
}
case readSizeStdField:
{
el->readSizeStd = sqlDouble(val);
break;
}
case readSizeMinField:
{
el->readSizeMin = sqlSigned(val);
break;
}
case readSizeMaxField:
{
el->readSizeMax = sqlSigned(val);
break;
}
case u4mReadCountField:
{
el->u4mReadCount = sqlSigned(val);
break;
}
case u4mUniquePosField:
{
el->u4mUniquePos = sqlSigned(val);
break;
}
case u4mUniqueRatioField:
{
el->u4mUniqueRatio = sqlDouble(val);
break;
}
case targetBaseCountField:
{
el->targetBaseCount = sqlLongLong(val);
break;
}
case targetSeqCountField:
{
el->targetSeqCount = sqlUnsigned(val);
break;
}
default:
internalErr();
break;
}
}
}
raToStructReaderCheckRequiredFields(reader, lf);
return el;
}
struct cdwQaPairedEndFastq *cdwQaPairedEndFastqFromNextRa(struct lineFile *lf, struct raToStructReader *reader)
/* Return next stanza put into an cdwQaPairedEndFastq. */
{
enum fields
{
fileId1Field,
concordanceField,
distanceMeanField,
distanceStdField,
distanceMinField,
distanceMaxField,
};
if (!raSkipLeadingEmptyLines(lf, NULL))
return NULL;
struct cdwQaPairedEndFastq *el;
AllocVar(el);
bool *fieldsObserved = reader->fieldsObserved;
bzero(fieldsObserved, reader->fieldCount);
char *tag, *val;
while (raNextTagVal(lf, &tag, &val, NULL))
{
struct hashEl *hel = hashLookup(reader->fieldIds, tag);
if (hel != NULL)
{
int id = ptToInt(hel->val);
if (fieldsObserved[id])
errAbort("Duplicate tag %s line %d of %s\n", tag, lf->lineIx, lf->fileName);
fieldsObserved[id] = TRUE;
switch (id)
{
case fileId1Field:
{
el->fileId1 = sqlUnsigned(val);
break;
}
case concordanceField:
{
el->concordance = sqlDouble(val);
break;
}
case distanceMeanField:
{
el->distanceMean = sqlDouble(val);
break;
}
case distanceStdField:
{
el->distanceStd = sqlDouble(val);
break;
}
case distanceMinField:
{
el->distanceMin = sqlDouble(val);
break;
}
case distanceMaxField:
{
el->distanceMax = sqlDouble(val);
break;
}
default:
internalErr();
break;
}
}
}
raToStructReaderCheckRequiredFields(reader, lf);
return el;
}
