bowtieParser.c

Go to the documentation of this file.

#include "format.h"
#include "log.h"
#include "linestream.h"
#include "common.h"
#include "bowtieParser.h"



static LineStream ls = NULL;



void bowtieParser_initFromFile (char *fileName)
{
  ls = ls_createFromFile (fileName);
  ls_bufferSet (ls,1);
}



void bowtieParser_initFromPipe (char *command)
{
  ls = ls_createFromPipe (command);
  ls_bufferSet (ls,1);
}



void bowtieParser_deInit (void)
{
  ls_destroy (ls);
}



static void bowtieParser_freeQuery (BowtieQuery *currBowtieQuery) 
{
  int i;
  BowtieEntry *currBowtieEntry;

  if (currBowtieQuery == NULL) {
    return;
  }
  hlr_free (currBowtieQuery->sequenceName);
  if (currBowtieQuery->entries != NULL) {
    for (i = 0; i < arrayMax (currBowtieQuery->entries); i++) {
      currBowtieEntry = arrp (currBowtieQuery->entries,i,BowtieEntry);
      hlr_free (currBowtieEntry->chromosome);
      hlr_free (currBowtieEntry->sequence);
      hlr_free (currBowtieEntry->quality);
      arrayDestroy (currBowtieEntry->mismatches);
    }
    arrayDestroy (currBowtieQuery->entries);
  }
  freeMem (currBowtieQuery);
}



static void bowtieParser_processMismatches (BowtieEntry *currEntry, char* token) 
{
  WordIter w;
  BowtieMismatch *currBowtieMismatch;
  char *item,*pos;

  currEntry->mismatches = arrayCreate (3,BowtieMismatch);
  if (token[0] == '\0') {
    return;
  }
  w = wordIterCreate (token,",",0);
  while (item = wordNext (w)) {
    currBowtieMismatch = arrayp (currEntry->mismatches,arrayMax (currEntry->mismatches),BowtieMismatch);
    pos = strchr (item,':');
    *pos = '\0';
    currBowtieMismatch->offset = atoi (item);
    currBowtieMismatch->referenceBase = *(pos + 1);
    currBowtieMismatch->readBase = *(pos + 3);
  }
  wordIterDestroy (w);
}



static void bowtieParser_processLine (char* line, BowtieQuery* currBowtieQuery) 
{
  WordIter w;
  BowtieEntry *currEntry;

  currEntry = arrayp (currBowtieQuery->entries,arrayMax (currBowtieQuery->entries),BowtieEntry);
  w = wordIterCreate (line,"\t",0);
  currEntry->strand = (wordNext (w))[0];
  currEntry->chromosome = hlr_strdup (wordNext (w));
  currEntry->position = atoi (wordNext (w));
  currEntry->sequence = hlr_strdup (wordNext (w));
  currEntry->quality = hlr_strdup (wordNext (w));
  wordNext (w);
  bowtieParser_processMismatches (currEntry,wordNext (w));
  wordIterDestroy (w);
}



static BowtieQuery* bowtieParser_processNextQuery (int freeMemory)
{
  char *line,*pos;
  static char *queryName = NULL;
  static char *prevBowtieQueryName = NULL;
  static BowtieQuery *currBowtieQuery = NULL;
  int first;

  if (!ls_isEof (ls)) {
    if (freeMemory) {
      bowtieParser_freeQuery (currBowtieQuery);
      currBowtieQuery = NULL;
    }
    AllocVar (currBowtieQuery);
    currBowtieQuery->entries = arrayCreate (5,BowtieEntry);
    first = 1;
    while (line = ls_nextLine (ls)) {
      if (line[0] == '\0') {
        continue;
      }
      pos = strchr (line,'\t');
      *pos = '\0';
      strReplace (&queryName,line);
      if (first == 1 || strEqual (prevBowtieQueryName,queryName)) {
        bowtieParser_processLine (pos + 1,currBowtieQuery); 
      }
      else {
        ls_back (ls,1);
        return currBowtieQuery;
      }
      if (first == 1) {
        currBowtieQuery->sequenceName = hlr_strdup (queryName);
        first = 0;
      }
      strReplace(&prevBowtieQueryName,queryName);
    }
    if (first == 1) {
      return NULL;
    }
    else {
      return currBowtieQuery;
    }
  }
  if (freeMemory) {
    bowtieParser_freeQuery (currBowtieQuery);
    currBowtieQuery = NULL;
  }
  return NULL;  
}



BowtieQuery* bowtieParser_nextQuery (void)
{
  return bowtieParser_processNextQuery (1);
}



Array  bowtieParser_getAllQueries ()
{
  Array bowtieQueries;
  BowtieQuery *currBowtieQuery;

  bowtieQueries = arrayCreate (100000,BowtieQuery);
  while (currBowtieQuery = bowtieParser_processNextQuery (0)) {
    array (bowtieQueries,arrayMax (bowtieQueries),BowtieQuery) = *currBowtieQuery;
    freeMem (currBowtieQuery);
  }
  return bowtieQueries;
}

---