inc/gff.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	gffLine
struct	gffGroup
struct	gffSource
struct	gffFeature
struct	gffSeqName
struct	gffGeneId
struct	gffFile
Defines
#define	gffTabOut(el, f)   gffOutput(el,f,'\t','\n');
#define	gffCommaOut(el, f)   gffOutput(el,f,',',',');
Functions
void	gffGroupFree (struct gffGroup **pGroup)
void	gffGroupFreeList (struct gffGroup **pList)
void	gffGroupLines (struct gffFile *gff)
gffFile *	gffRead (char *fileName)
gffFile *	gffFileNew (char *fileName)
void	gffFileAdd (struct gffFile *gff, char *fileName, int baseOffset)
void	gffFileAddRow (struct gffFile *gff, int baseOffset, char *words[], int wordCount, char *fileName, int lineIx)
void	gffFileFree (struct gffFile **pGff)
int	gffLineCmp (const void *va, const void *vb)
void	gffOutput (struct gffLine *el, FILE *f, char sep, char lastSep)
boolean	gffHasGtfGroup (char *line)

---

Define Documentation

#define gffCommaOut	(	el,
		f		)	gffOutput(el,f,',',',');

Definition at line 136 of file gff.h.

#define gffTabOut	(	el,
		f		)	gffOutput(el,f,'\t','\n');

Definition at line 133 of file gff.h.

---

Function Documentation

void gffFileAdd	(	struct gffFile *	gff,
		char *	fileName,
		int	baseOffset
	)

Definition at line 324 of file gff.c.

References chopTabs, gffFile::featureList, lineFile::fileName, gffFile::geneIdList, gffFileAddRow(), gffFile::groupList, lineFileClose(), lineFileNext(), lineFileOpen(), lineFile::lineIx, gffFile::lineList, gffFile::seqList, slReverse(), gffFile::sourceList, and TRUE.

Referenced by gffRead().

{
/* Open file and do basic allocations. */
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line, *words[9];
int lineSize, wordCount;

while (lineFileNext(lf, &line, &lineSize))
    {
    if (line[0] != '#')
        {
        wordCount = chopTabs(line, words);
        if (wordCount > 0)
            gffFileAddRow(gff, baseOffset, words, wordCount, lf->fileName, lf->lineIx);
        }
    }
slReverse(&gff->lineList);
slReverse(&gff->seqList);
slReverse(&gff->sourceList);
slReverse(&gff->featureList);
slReverse(&gff->groupList);
slReverse(&gff->geneIdList);
lineFileClose(&lf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffFileAddRow	(	struct gffFile *	gff,
		int	baseOffset,
		char *	words[],
		int	wordCount,
		char *	fileName,
		int	lineIx
	)

Definition at line 244 of file gff.c.

References AllocVar, gffLine::end, gffLine::feature, gffFile::featureHash, gffFile::featureList, gffLine::frame, gffSyntaxError(), gffTnName(), gffLine::group, gffFile::groupHash, gffFile::groupList, hashAdd(), hashLookup(), gffFile::isGtf, isGtfGroup(), gffFile::lineList, gffSeqName::name, hashEl::name, gffSource::name, gffFeature::name, gffGroup::name, parseGtfEnd(), gffLine::score, gffLine::seq, gffGroup::seq, gffFile::seqHash, gffFile::seqList, slAddHead, gffLine::source, gffGroup::source, gffFile::sourceHash, gffFile::sourceList, gffLine::start, gffLine::strand, TRUE, and gffFile::typeKnown.

Referenced by gffFileAdd().

{
struct hashEl *hel;
struct gffLine *gl;

if (wordCount < 8)
    gffSyntaxError(fileName, lineIx, "Word count less than 8 ");
AllocVar(gl);

if ((hel = hashLookup(gff->seqHash, words[0])) == NULL)
    {
    struct gffSeqName *el;
    AllocVar(el);
    hel = hashAdd(gff->seqHash, words[0], el);
    el->name = hel->name;
    slAddHead(&gff->seqList, el);
    }
gl->seq = hel->name;

if ((hel = hashLookup(gff->sourceHash, words[1])) == NULL)
    {
    struct gffSource *el;
    AllocVar(el);
    hel = hashAdd(gff->sourceHash, words[1], el);
    el->name = hel->name;
    slAddHead(&gff->sourceList, el);
    }
gl->source = hel->name;

if ((hel = hashLookup(gff->featureHash, words[2])) == NULL)
    {
    struct gffFeature *el;
    AllocVar(el);
    hel = hashAdd(gff->featureHash, words[2], el);
    el->name = hel->name;
    slAddHead(&gff->featureList, el);
    }
gl->feature = hel->name;

if (!isdigit(words[3][0]) || !isdigit(words[4][0]))
   gffSyntaxError(fileName, lineIx, "col 3 or 4 not a number ");        
gl->start = atoi(words[3])-1 + baseOffset;
gl->end = atoi(words[4]) + baseOffset;
gl->score = atof(words[5]);
gl->strand = words[6][0];
gl->frame = words[7][0];

if (wordCount >= 9)
    {
    if (!gff->typeKnown)
        {
        gff->typeKnown = TRUE;
        gff->isGtf = isGtfGroup(words[8]);
        }
    if (gff->isGtf)
        {
        parseGtfEnd(words[8], gff, gl, fileName, lineIx);
        }
    else
        {
        char *tnName = gffTnName(gl->seq, words[8]);
        if ((hel = hashLookup(gff->groupHash, tnName)) == NULL)
            {
            struct gffGroup *group;
            AllocVar(group);
            hel = hashAdd(gff->groupHash, tnName, group);
            group->name = hel->name;
            group->seq = gl->seq;
            group->source = gl->source;
            slAddHead(&gff->groupList, group);
            }
        gl->group = hel->name;
        }
    }
slAddHead(&gff->lineList, gl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffFileFree

(

struct gffFile **

pGff

)

Definition at line 39 of file gff.c.

References gffFile::exonHash, gffFile::featureHash, gffFile::featureList, gffFile::fileName, freeHash(), freeMem(), freez(), gffFile::geneIdHash, gffFile::geneIdList, gffGroupFreeList(), gffFile::groupHash, gffFile::groupList, gffFile::intronStatusHash, gffFile::lineList, gffFile::proteinIdHash, gffFile::seqHash, gffFile::seqList, slFreeList(), gffFile::sourceHash, and gffFile::sourceList.

{
struct gffFile *gff;
if ((gff = *pGff) != NULL)
    {
    freeMem(gff->fileName);
    freeHash(&gff->seqHash);
    freeHash(&gff->sourceHash);
    freeHash(&gff->featureHash);
    freeHash(&gff->groupHash);
    freeHash(&gff->geneIdHash);
    freeHash(&gff->exonHash);
    freeHash(&gff->intronStatusHash);
    freeHash(&gff->proteinIdHash);
    slFreeList(&gff->lineList);
    slFreeList(&gff->seqList);
    slFreeList(&gff->sourceList);
    slFreeList(&gff->featureList);
    slFreeList(&gff->geneIdList);
    gffGroupFreeList(&gff->groupList);
    freez(pGff);
    }
}

Here is the call graph for this function:

struct gffFile* gffFileNew

(

char *

fileName

)

[read]

Definition at line 350 of file gff.c.

References AllocVar, cloneString(), gffFile::exonHash, gffFile::featureHash, gffFile::fileName, gffFile::geneIdHash, gffFile::groupHash, gffFile::intronStatusHash, newHash(), gffFile::proteinIdHash, gffFile::seqHash, and gffFile::sourceHash.

Referenced by gffRead().

{
struct gffFile *gff;
AllocVar(gff);
gff->fileName = cloneString(fileName);
gff->seqHash = newHash(6);
gff->sourceHash = newHash(6);
gff->featureHash = newHash(6);
gff->groupHash = newHash(12);
gff->geneIdHash = newHash(12);
gff->exonHash = newHash(16);
gff->intronStatusHash = newHash(4);
gff->proteinIdHash = newHash(12);
return gff;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffGroupFree

(

struct gffGroup **

pGroup

)

Definition at line 15 of file gff.c.

References freez(), gffGroup::lineList, and slFreeList().

Referenced by gffGroupFreeList().

{
struct gffGroup *group;
if ((group = *pGroup) != NULL)
    {
    slFreeList(&group->lineList);
    freez(pGroup);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffGroupFreeList

(

struct gffGroup **

pList

)

Definition at line 26 of file gff.c.

References gffGroupFree(), and gffGroup::next.

Referenced by gffFileFree().

{
struct gffGroup *el, *next;
for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    gffGroupFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffGroupLines

(

struct gffFile *

gff

)

Definition at line 394 of file gff.c.

References getGroupBoundaries(), gffLineCmp(), gffLine::group, gffFile::groupHash, gffFile::groupList, hashLookup(), gffFile::lineList, gffGroup::lineList, gffLine::next, gffGroup::next, nextLine(), slAddHead, slReverse(), slSort(), and hashEl::val.

{
struct gffLine *line, *nextLine;
struct hash *groupHash = gff->groupHash;
char *groupName;
struct gffGroup *group;
struct gffLine *ungroupedLines = NULL;

for (line = gff->lineList; line != NULL; line = nextLine)
    {
    nextLine = line->next;
    if ((groupName = line->group) != NULL)
        {
        struct hashEl *hel = hashLookup(groupHash, groupName);
        group = hel->val;
        slAddHead(&group->lineList, line);
        }
    else
        {
        slAddHead(&ungroupedLines, line);
        }
    }

/* Restore ungrouped lines to gff->lineList. */
slReverse(&ungroupedLines);
gff->lineList = ungroupedLines;

/* Restore order of grouped lines and fill in start and end. */
for (group = gff->groupList; group != NULL; group = group->next)
    {
    slSort(&group->lineList, gffLineCmp);
    getGroupBoundaries(group);
    }
}

Here is the call graph for this function:

boolean gffHasGtfGroup

(

char *

line

)

Definition at line 112 of file gff.c.

References chopTabs, cloneString(), FALSE, freeMem(), isGtfGroup(), and TRUE.

{
char *words[10];
char *dupe = cloneString(line);
int wordCt = chopTabs(dupe, words);
boolean isGtf = FALSE;
if (wordCt >= 9) 
    if (isGtfGroup(words[8]))
        isGtf = TRUE;
freeMem(dupe);
return isGtf;
}

Here is the call graph for this function:

int gffLineCmp	(	const void *	va,
		const void *	vb
	)

Definition at line 64 of file gff.c.

References gffLine::end, gffLine::seq, and gffLine::start.

Referenced by gffGroupLines().

{
const struct gffLine *a = *((struct gffLine **)va);
const struct gffLine *b = *((struct gffLine **)vb);
int diff;

/* for overlaping starts, sort by end, genePredFromGroupedGtf() depends on
 * this */
diff = strcmp(a->seq, b->seq);
if (diff == 0)
    diff = a->start - b->start;
if (diff == 0)
    diff = a->end - b->end;
return diff;
}

Here is the caller graph for this function:

void gffOutput	(	struct gffLine *	el,
		FILE *	f,
		char	sep,
		char	lastSep
	)

Definition at line 431 of file gff.c.

References gffLine::end, gffLine::exonId, gffLine::feature, gffLine::frame, gffLine::geneId, gffLine::group, gffLine::score, gffLine::seq, gffLine::source, gffLine::start, and gffLine::strand.

{
if (sep == ',') fputc('"',f);
fprintf(f, "%s", el->seq);
if (sep == ',') fputc('"',f);
fputc(sep,f);
if (sep == ',') fputc('"',f);
fprintf(f, "%s", el->source);
if (sep == ',') fputc('"',f);
fputc(sep,f);
if (sep == ',') fputc('"',f);
fprintf(f, "%s", el->feature);
if (sep == ',') fputc('"',f);
fputc(sep,f);
fprintf(f, "%u", el->start+1);
fputc(sep,f);
fprintf(f, "%u", el->end);
fputc(sep,f);
fprintf(f, "%f", el->score);
fputc(sep,f);
if (sep == ',') fputc('"',f);
fprintf(f, "%c", el->strand);
if (sep == ',') fputc('"',f);
fputc(sep,f);
if (sep == ',') fputc('"',f);
fprintf(f, "%c", el->frame);
if (sep == ',') fputc('"',f);
fputc(sep,f);
if (sep == ',') fputc('"',f);
if (el->geneId != NULL)
    fprintf(f, "gene_id %s\"%s%s\"; ",
            (sep == ',') ? "\\" : "",
            el->geneId,
            (sep == ',') ? "\\" : "");
fprintf(f, "transcript_id %s\"%s%s\"; ",
        (sep == ',') ? "\\" : "",
        el->group,
        (sep == ',') ? "\\" : "");
if (el->exonId != NULL)
    fprintf(f, "exon_id %s\"%s%s\"; ",
            (sep == ',') ? "\\" : "",
            el->exonId,
            (sep == ',') ? "\\" : "");
if (sep == ',') fputc('"',f);
fputc(lastSep,f);
}

struct gffFile* gffRead

(

char *

fileName

)

[read]

Definition at line 367 of file gff.c.

References gffFileAdd(), and gffFileNew().

{
struct gffFile *gff = gffFileNew(fileName);
gffFileAdd(gff, fileName, 0);
return gff;
}

Here is the call graph for this function:

---