ContigIterator_AMOS.hh

Go to the documentation of this file.

#ifndef CONTIG_ITERATOR_HH
#define CONTIG_ITERATOR_HH 1

#include "Contig_AMOS.hh"
#include "Read_AMOS.hh"

#include <map>
#include <list>
#include <vector>
#include <string>
#include <queue>
#include <functional>

namespace AMOS 
{

class TiledRead_t 
{
public:

  TiledRead_t(Tile_t tile, Read_t red, int readidx);

  char base(Pos_t gindex) const
  {
    if (gindex < m_loffset || gindex > m_roffset) { return ' '; }
    return m_seq[gindex-m_loffset];
  }
  
  int qv(Pos_t gindex) const
  {
    if (gindex < m_loffset || gindex > m_roffset) { return -1; }
    return m_qual[gindex-m_loffset] - MIN_QUALITY;
  }

  int32_t m_readidx;

  Pos_t m_loffset;

  Pos_t m_roffset;

  bool m_isRC;

  ID_t m_fragid;

  ID_t m_iid;

  std::string m_eid;

private:
  std::string m_seq;
  
  std::string m_qual;
};

typedef std::list<TiledRead_t> TiledReadList_t;

struct TileOrderCmp
{
  bool operator () (const Tile_t & a, const Tile_t & b)
  {
    int offdiff = b.offset - a.offset;

    if (offdiff)
    {
      if (offdiff < 0) { return false; }
      return true;
    }

    int lendiff = (b.getGappedLength()) - (a.getGappedLength());

    if (lendiff)
    {
      if (lendiff < 0) { return false; }
      return true;
    }

    return (a.source < b.source);
  }
};




class BaseStats_t
{
public:
  BaseStats_t(char base);

  char m_base;

  int  m_cumqv;

  int  m_maxqv;

  std::vector<TiledReadList_t::const_iterator> m_reads;

  void addRead(TiledReadList_t::const_iterator tile, Pos_t gindex);
};



struct BaseStatsCmp
{
  bool operator() (const BaseStats_t * a, const BaseStats_t * b)
  {
    if (a->m_reads.size() == b->m_reads.size())
    {
      if (a->m_cumqv == b->m_cumqv)
      {
        return a->m_maxqv > b->m_maxqv;
      }

      return a->m_cumqv > b->m_cumqv;
    }
    
    return a->m_reads.size() > b->m_reads.size();
  }
};



class ContigIterator_t;

class Column_t 
{
public:
  Column_t (ContigIterator_t & ci);

  std::vector<BaseStats_t *> getBaseInfo();

  Pos_t m_gindex;
  
  Pos_t m_uindex;

  char m_cons;
  
  int m_cqv;

  int32_t m_depth;

  std::map<char, BaseStats_t> m_baseinfo;
};



class ContigIterator_t 
{
public:
  ContigIterator_t(Contig_t & ctg, Bank_t * rdbank);

  bool seek(Pos_t gindex);

  bool advanceNext();

  Pos_t uindex() const;

  Pos_t gindex() const { return m_gindex; }

  bool hasSNP() const;

  char cons()   const { return m_consensus[m_gindex]; }
  
  int cqv()    const { return m_consqual[m_gindex] - MIN_QUALITY;  }

  Column_t getColumn();

  const Contig_t &        getContig()      const { return m_contig; }


  const TiledReadList_t & getTilingReads() const { return m_tilingreads; }




private:
  void renderTile(Tile_t & tile, int tilingIndex);

  struct ReadListItEndCmp
  {
    bool operator () (const TiledReadList_t::iterator & a, const TiledReadList_t::iterator & b)
    {
      return (a->m_roffset > b->m_roffset);
    }
  };

  std::priority_queue<TiledReadList_t::iterator, std::vector<TiledReadList_t::iterator>, ReadListItEndCmp > m_ends;

  Bank_t * m_readBank;

  std::string m_consensus;

  std::string m_consqual;

  Pos_t m_gindex;

  Pos_t m_uindex;

  int32_t m_currenttile;

  int32_t m_numreads;

  Contig_t m_contig;

  static int32_t s_tilingreadsoffset;
  
  int32_t m_tilingreadsoffset;

  TiledReadList_t m_tilingreads;
};


} // namespace AMOS


#endif

---