18d303bb4f14e1edff401c8a85276ff1344f0f37
angie
  Tue Apr 3 10:18:14 2012 -0700
Feature #6152 (Variant Annotation Tool): Added annoStreamVcf, whichled to yet more significant changes to annoRow: instead of every row
declaring its type and annoRow{Free,Clone} taking a numCols argument
that is meaningless for wig, now annoRow{Free,Clone} take the row's
source annoStreamer as an argument.  The annoStreamer now has public
members (rowType and numCols) that provide all information needed about
the row.  annoStreamer constructors need to set rowType.

diff --git src/lib/annoGrator.c src/lib/annoGrator.c
index c02c13e..2a1046c 100644
--- src/lib/annoGrator.c
+++ src/lib/annoGrator.c
@@ -28,31 +28,31 @@
 struct annoRow *qRow, *prevQRow = NULL, *nextQRow;
 for (qRow = self->qHead;  qRow != NULL;  qRow = nextQRow)
     {
     nextQRow = qRow->next;
     int cDifRowP = strcmp(qRow->chrom, chrom);
     if (cDifRowP > 0 || (cDifRowP == 0 && qRow->start >= start))
 	break;
     else if (cDifRowP < 0 || qRow->end < start)
 	{
 	if (prevQRow == NULL)
 	    self->qHead = qRow->next;
 	else
 	    prevQRow->next = qRow->next;
 	if (self->qTail == qRow)
 	    self->qTail = prevQRow;
-	annoRowFree(&qRow, self->numSrcCols);
+	annoRowFree(&qRow, (struct annoStreamer *)self);
 	}
     else
 	prevQRow = qRow;
     }
 }
 
 INLINE void agCheckInternalSorting(struct annoRow *newRow, struct annoRow *qTail)
 /* Die if newRow precedes qTail. */
 {
 if (qTail != NULL)
     {
     int cDifNewTail = strcmp(newRow->chrom, qTail->chrom);
     if (cDifNewTail < 0)
 	errAbort("Unsorted input from internal source (%s < %s)",
 		 newRow->chrom, qTail->chrom);
@@ -66,31 +66,31 @@
 /* Fetch rows until we are sure we have all items that start to the left of end,
  * i.e. we have an item that starts at/after end or we hit eof. */
 {
 while (!self->eof &&
        (self->qTail == NULL || strcmp(self->qTail->chrom, chrom) < 0 || self->qTail->start < end))
     {
     struct annoRow *newRow = self->mySource->nextRow(self->mySource);
     if (newRow == NULL)
 	self->eof = TRUE;
     else
 	{
 	agCheckInternalSorting(newRow, self->qTail);
 	int cDifNewP = strcmp(newRow->chrom, chrom);
 	if (cDifNewP < 0)
 	    // newRow->chrom comes before chrom; skip over newRow
-	    annoRowFree(&newRow, self->numSrcCols);
+	    annoRowFree(&newRow, (struct annoStreamer *)self);
 	else
 	    {
 	    // Add newRow to qTail
 	    if (self->qTail == NULL)
 		{
 		if (self->qHead != NULL)
 		    errAbort("qTail is NULL but qHead is non-NULL");
 		self->qHead = self->qTail = newRow;
 		}
 	    else
 		{
 		self->qTail->next = newRow;
 		self->qTail = newRow;
 		}
 	    if (cDifNewP > 0)
@@ -106,89 +106,89 @@
 /* Given a single row from the primary source, get all overlapping rows from internal
  * source, and produce joined output rows.  If retRJFilterFailed is non-NULL and any
  * overlapping row has a rightJoin filter failure (see annoFilter.h),
  * set retRJFilterFailed and stop. */
 {
 struct annoRow *rowList = NULL;
 agCheckPrimarySorting(self, primaryRow);
 agTrimToStart(self, primaryRow->chrom, primaryRow->start);
 agFetchToEnd(self, primaryRow->chrom, primaryRow->end);
 boolean rjFailHard = (retRJFilterFailed != NULL);
 struct annoRow *qRow;
 for (qRow = self->qHead;  qRow != NULL;  qRow = qRow->next)
     {
     if (qRow->start < primaryRow->end && qRow->end > primaryRow->start)
 	{
-	slAddHead(&rowList, annoRowClone(qRow, self->numSrcCols));
+	slAddHead(&rowList, annoRowClone(qRow, (struct annoStreamer *)self));
 	if (rjFailHard && qRow->rightJoinFail)
 	    {
 	    *retRJFilterFailed = TRUE;
 	    break;
 	    }
 	}
     }
 slReverse(&rowList);
 return rowList;
 }
 
 void annoGratorClose(struct annoStreamer **pSelf)
 /* Free self (including mySource). */
 {
 if (pSelf == NULL)
     return;
 struct annoGrator *self = *(struct annoGrator **)pSelf;
 self->mySource->close(&(self->mySource));
-annoRowFreeList(&(self->qHead), self->numSrcCols);
+annoRowFreeList(&(self->qHead), (struct annoStreamer *)self);
 freeMem(self->prevPChrom);
 freez(pSelf);
 }
 
 static struct annoRow *noNextRow(struct annoStreamer *self)
 /* nextRow() is N/A for annoGrator, which needs caller to use integrate() instead. */
 {
 errAbort("nextRow() called on annoGrator object, but integrate() should be called instead");
 return NULL;
 }
 
 static void agReset(struct annoGrator *self)
 /* Reset all position associated with state */
 {
 freez(&self->prevPChrom);
 self->prevPStart = 0;
 self->eof = FALSE;
-annoRowFreeList(&(self->qHead), self->numSrcCols);
+annoRowFreeList(&(self->qHead), (struct annoStreamer *)self);
 self->qTail = NULL;
 }
 
 void annoGratorSetRegion(struct annoStreamer *vSelf, char *chrom, uint rStart, uint rEnd)
 /* Set genomic region for query, and reset internal state. */
 {
 struct annoGrator *self = (struct annoGrator *)vSelf;
 self->mySource->setRegion((struct annoStreamer *)(self->mySource), chrom, rStart, rEnd);
 agReset(self);
 }
 
 void annoGratorSetQuery(struct annoStreamer *vSelf, struct annoGratorQuery *query)
 /* Set query (to be called only by annoGratorQuery which is created after streamers). */
 {
 struct annoGrator *self = (struct annoGrator *)vSelf;
 self->streamer.query = query;
 self->mySource->setQuery((struct annoStreamer *)(self->mySource), query);
 }
 
 struct annoGrator *annoGratorNew(struct annoStreamer *mySource)
 /* Make a new integrator of columns from mySource with (positions of) rows passed to integrate().
  * mySource becomes property of the new annoGrator. */
 {
 struct annoGrator *self;
 AllocVar(self);
 struct annoStreamer *streamer = &(self->streamer);
 annoStreamerInit(streamer, mySource->getAutoSqlObject(mySource));
+streamer->rowType = mySource->rowType;
 streamer->setRegion = annoGratorSetRegion;
 streamer->setQuery = annoGratorSetQuery;
 streamer->nextRow = noNextRow;
 streamer->close = annoGratorClose;
 self->integrate = annoGratorIntegrate;
 self->mySource = mySource;
-self->numSrcCols = slCount(mySource->asObj->columnList);
 return self;
 }