Contig_AMOS.hh

Go to the documentation of this file.

#ifndef __Contig_AMOS_HH
#define __Contig_AMOS_HH 1

#include "Sequence_AMOS.hh"
#include "Layout_AMOS.hh"
#include <vector>




namespace AMOS {

//================================================ Contig_t ====================
//==============================================================================
class Contig_t : public Sequence_t
{
  
private:
  bool gapsvalid_m;                   //<! indicates if gaps_m is up to date
  std::vector<Pos_t> gaps_m;          
  std::vector<Tile_t> reads_m;        

  //--------------------------------------------------- compress ---------------
  void compress ( );


  //--------------------------------------------------- uncompress -------------
  void uncompress ( );


  //--------------------------------------------------- indexGaps --------------
  void indexGaps();

protected:

  //--------------------------------------------------- readRecord -------------
  virtual void readRecord (std::istream & fix, std::istream & var);


  //--------------------------------------------------- readRecordFix ----------
  virtual void readRecordFix (std::istream & fix);


  //--------------------------------------------------- writeRecord ------------
  virtual void writeRecord (std::ostream & fix, std::ostream & var) const;


public:

  static const NCode_t NCODE;


  //--------------------------------------------------- Contig_t ---------------
  Contig_t ( )
   : gapsvalid_m(false)
  {

  }


  //--------------------------------------------------- Contig_t ---------------
  Contig_t (const Contig_t & source)
  {
    *this = source;
  }


  //--------------------------------------------------- ~Contig_t --------------
  ~Contig_t ( )
  {

  }


  //--------------------------------------------------- clear ------------------
  virtual void clear ( )
  {
    Sequence_t::clear( );
    gaps_m . clear( );
    reads_m . clear( );
    gapsvalid_m = false;
  }


  //--------------------------------------------------- gap2ungap --------------
  Pos_t gap2ungap (Pos_t gap);


  //--------------------------------------------------- ungap2gap --------------
  Pos_t ungap2gap (Pos_t ungap);
  
  //--------------------------------------------------- getGCContent --------------
  virtual double getGCContent (const Range_t & rng) const
  {
    int gc = 0;
    int all = 0;

    int start = rng.getLo();
    int stop = rng.getHi();

    if (stop > length_m)
      AMOS_THROW_ARGUMENT("Can't compute GC Content beyond sequence length");

    // skip ambiguities, gaps

    for (int i = start; i < stop; i++)
    {
      switch(seq_m[i])
      {
        case 'A':
        case 'a': 
        case 'T':
        case 't': all++; break;

        case 'C':
        case 'c':
        case 'G':
        case 'g': all++; gc++; break;
      };
    }

    return (all) ? ((double)gc)/all : 0.0;
  }

  //--------------------------------------------------- getGCContent --------------
  virtual double getGCContent ( ) const
  {
    return getGCContent(Range_t(0, length_m));
  }



  //--------------------------------------------------- getNCode ---------------
  virtual NCode_t getNCode ( ) const
  {
    return Contig_t::NCODE;
  }


  //--------------------------------------------------- getReadTiling ----------
  const std::vector<Tile_t> & getReadTiling ( ) const
  {
    return reads_m;
  }


  //--------------------------------------------------- getReadTiling ----------
  std::vector<Tile_t> & getReadTiling ( )
  {
    return reads_m;
  }


  //--------------------------------------------------- getSpan ----------------
  Size_t getSpan ( ) const;


  //--------------------------------------------------- getUngappedLength ------
  Size_t getUngappedLength ( ) const;


  //--------------------------------------------------- getUngappedQualString --
  std::string getUngappedQualString ( ) const
  {
    return getUngappedQualString (Range_t (0, getLength( )));
  }


  //--------------------------------------------------- getUngappedQualString --
  std::string getUngappedQualString (Range_t range) const;


  //--------------------------------------------------- getUngappedSeqString ---
  std::string getUngappedSeqString ( ) const
  {
    return getUngappedSeqString (Range_t (0, getLength( )));
  }


  //--------------------------------------------------- getUngappedSeqString ---
  std::string getUngappedSeqString (Range_t range) const;



  //--------------------------------------------------- insertGapColumn -------
  void insertGapColumn (Pos_t gindex);



  //--------------------------------------------------- getCovStat -------------
  double getCovStat(const double globalArrivalRate) const;



  //--------------------------------------------------- getAvgRho --------------
  double getAvgRho( ) const;



  //--------------------------------------------------- readMessage ------------
  virtual void readMessage (const Message_t & msg);


  //--------------------------------------------------- readUMD ----------------
  bool readUMD (std::istream & in);

  //--------------------------------------------------- reverseComplement ------
  void reverseComplement();


  //--------------------------------------------------- setReadTiling ----------
  void setReadTiling (const std::vector<Tile_t> & reads)
  {
    reads_m = reads;
  }


  //--------------------------------------------------- setReadTiling ----------
  void setReadTiling (const Layout_t & layout)
  {
    reads_m = layout . getTiling( );
  }

  //--------------------------------------------------- setSequence -----------
  void setSequence (const char * seq, const char * qual)
  {
    gapsvalid_m = false;
    Sequence_t::setSequence(seq, qual);
  }

  //--------------------------------------------------- setSequence -----------
  void setSequence (const std::string & seq, const std::string & qual)
  {
    gapsvalid_m = false;
    Sequence_t::setSequence(seq, qual);
  }

  //--------------------------------------------------- writeMessage -----------
  virtual void writeMessage (Message_t & msg) const;


  //--------------------------------------------------- writeUMD ---------------
  void writeUMD (std::ostream & out) const;

};

} // namespace AMOS

#endif // #ifndef __Contig_AMOS_HH

---