readsinrect.h

Go to the documentation of this file.

#ifndef READS_IN_RECT_H
#define READS_IN_RECT_H
 
#include <cassert>

#include "generaldata.h"
#include "trappertypes.h"
#include "readdata.h"

class ReadsInRect
{
public:
  ReadsInRect(TrapperDoc * doc) {
    cursor_positioned = false;
    need_to_call_first = true;
    readIt  = new Database::SecondaryIterator<ReadData>( "pos", doc, "ReadData" );
    x_dna = 0;
    y_dna = 0;
    w_dna = 0;
    h_dna = 0;
  }
  ~ReadsInRect() {
    delete readIt;
  }
  void setWindowCoord(TR_DNA x_dna_, TR_DNA y_dna_,TR_DNA w_dna_,TR_DNA h_dna_ ) {
    x_dna = x_dna_;
    y_dna = y_dna_;
    w_dna = w_dna_;
    h_dna = h_dna_;
    return;
  }
  ReadData * first() 
  { 
    y_iter = y_dna; 
    x_iter = x_dna; 
    cursor_positioned = false;  
    need_to_call_first = false;
    return find(); 
  }
  ReadData * next() 
  {  
     return find(); 
  }
private:
  ReadData * find() {
    if ( need_to_call_first ) {
      return NULL;
    }
    
    if ( w_dna <= 0 ) { 
      //Bug fix
      return NULL;
    }
    
    while ( y_iter < y_dna + h_dna ) {
      
      while ( x_iter < x_dna + w_dna ) {
        int ret;
        /* 
           It is faster to get the next data item by invoking next() on the cursor,
           than doing a new search ( i.e. setRange() ).
           Because the data item are sorted in the berkeley db first y-wise and
           then x-wise we use next() when we want to get the next Read to the right 
           in the same row. If we change rows we have to do a new search ( i.e. setRange() ).
           We use the boolean cursor_positioned to indicate which of them to use.
        */
        if ( cursor_positioned ) {
          ret = readIt->next();
        }
        else {
          readIt->key()->setRow( y_iter );
          readIt->key()->setEndPos( x_iter );
          ret = readIt->setRange();
          
        }
        if ( ret != 0 ) {
          
          // no records left in the sorted index
          need_to_call_first = true;
          return NULL;
        }
        ReadData * d = readIt->answer();
        assert( d );
        if ( hasRightEndInsideWindow( d ) ) {
          cursor_positioned = true;
          
        } 
        else {
          
          cursor_positioned = false;
          x_iter = x_dna;
          y_iter = d->row();
          if ( d->endPos() >= x_dna + w_dna ) { // we won't find any more reads on this row
            ++y_iter;
            
          }
        }
        if ( hasAnythingInsideWindow( d ) ) {   
          
          return d;               
        } 
        
      }
    }
    need_to_call_first = true;
    cursor_positioned = false;
    return NULL;
  }
  bool hasAnythingInsideWindow( ReadData * d ) {
    if ( d->endPos() < x_dna )
      return false;
    if (( d->startPos() < x_dna + w_dna ) && ( d->row() < y_dna + h_dna ))
      return true;
    //default
    return false;
  }
  
  bool hasRightEndInsideWindow( ReadData * d ) {
    return (( d->endPos() < x_dna + w_dna )
            && ( d->endPos() >= x_dna ) );
  }
  
  
  
  bool cursor_positioned;
  bool need_to_call_first;
  TR_DNA x_dna;
  TR_DNA y_dna;
  TR_DNA w_dna;
  TR_DNA h_dna;
  TR_DNA x_iter;
  TR_DNA y_iter;
  Database::SecondaryIterator<ReadData> * readIt;
};

#endif //READS_IN_RECT_H

---