Kmer_AMOS.hh

Go to the documentation of this file.

#ifndef __Kmer_AMOS_HH
#define __Kmer_AMOS_HH 1

#include "Universal_AMOS.hh"
#include <vector>
#include <string>




namespace AMOS {

//================================================ Kmer_t ======================
//==============================================================================
class Kmer_t : public Universal_t
{
  
private:

  uint8_t * seq_m;              
  uint32_t count_m;             
  uint8_t length_m;             
  std::vector<ID_t> reads_m;    


protected:

  static const uint8_t ADENINE_BITS  = 0x0;   
  static const uint8_t CYTOSINE_BITS = 0x40;  
  static const uint8_t GUANINE_BITS  = 0x80;  
  static const uint8_t THYMINE_BITS  = 0xC0;  
  static const uint8_t SEQ_BITS      = 0xC0;  


  //--------------------------------------------------- compress ---------------
  static uint8_t compress (char seqchar)
  {
    switch ( toupper(seqchar) )
      {
      case 'A': return ADENINE_BITS;
      case 'C': return CYTOSINE_BITS;
      case 'G': return GUANINE_BITS;
      case 'T': return THYMINE_BITS;
      default:
        AMOS_THROW_ARGUMENT ((std::string)"Invalid Kmer character " + seqchar);
      }
  }


  //--------------------------------------------------- uncompress -------------
  static char uncompress (uint8_t byte)
  {
    switch ( byte & SEQ_BITS )
      {
      case ADENINE_BITS:  return 'A';
      case CYTOSINE_BITS: return 'C';
      case GUANINE_BITS:  return 'G';
      case THYMINE_BITS:  return 'T';
      default:
        AMOS_THROW_ARGUMENT ("Unknown logic error");
      }
  }


  //--------------------------------------------------- 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;

  static const uint8_t MAX_LENGTH;


  //--------------------------------------------------- Kmer_t -----------------
  Kmer_t ( )
  {
    seq_m = NULL;
    count_m = length_m = 0;
  }


  //--------------------------------------------------- Kmer_t -----------------
  Kmer_t (const Kmer_t & source)
  {
    seq_m = NULL;
    *this = source;
  }


  //--------------------------------------------------- ~Kmer_t ----------------
  ~Kmer_t ( )
  {
    free (seq_m);
  }


  //--------------------------------------------------- clear ------------------
  virtual void clear ( );


  //--------------------------------------------------- getBase ----------------
  //  -- developers note --
  //  If we imagine consecutive bytes stored left-to-right, then we can index
  //  the seqchars left-to-right as follows:
  //   [0] [1] [2] [3]   [4] [5] [6] [7]  ... seqchars
  //  [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] ... bits
  //  [byte 0         ] [byte 1         ] ... bytes
  //  Thus, to retrieve seqchar 5 we need to index byte 1. Since uncompress
  //  expects the sequence bits in the high-order end of the byte, we left
  //  shift 2-bits. The uncompress method will take care of the necessary
  //  masking.
  //
  char getBase (Pos_t index) const
  {
    if ( index < 0 || index >= length_m )
      AMOS_THROW_ARGUMENT ("Requested kmer index is out of range");
    return uncompress ((seq_m [index / 4]) << (index % 4 * 2));
  }


  //--------------------------------------------------- getCount ---------------
  uint32_t getCount ( ) const
  {
    return count_m;
  }


  //--------------------------------------------------- getLength --------------
  uint8_t getLength ( ) const
  {
    return length_m;
  }


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


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


  //--------------------------------------------------- getReads ---------------
  std::vector<ID_t> & getReads ( )
  {
    return reads_m;
  }


  //--------------------------------------------------- getSeqString -----------
  std::string getSeqString ( ) const;


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


  //--------------------------------------------------- setBase ----------------
  //  -- developers note --
  //  If we imagine consecutive bytes stored left-to-right, then we can index
  //  the seqchars left-to-right as follows:
  //   [0] [1] [2] [3]   [4] [5] [6] [7]  ... seqchars
  //  [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] ... bits
  //  [byte 0         ] [byte 1         ] ... bytes
  //  Thus, to set seqchar 2, we need overwrite the bits at the 2^3 and 2^2
  //  positions of byte 0. Since compress returns the sequence bits in the
  //  high-order end of the byte, we right-shift the return value 4-bits and
  //  "OR" it with the stored byte (making sure to clear those two bits first).
  //
  void setBase (char seqchar, Pos_t index)
  {
    if ( index < 0 || index >= length_m )
      AMOS_THROW_ARGUMENT ("Requested kmer index is out of range");

    int offset = index % 4 * 2;              // the bitmask offset
    uint8_t * seqp = seq_m + index / 4;      // the required byte

    //-- Delete the previous two bits, then set the two new bits
    *seqp &= ~(SEQ_BITS >> offset);
    *seqp |= compress (seqchar) >> offset;
  }


  //--------------------------------------------------- setCount ---------------
  void setCount (uint32_t count)
  {
    count_m = count;
  }


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


  //--------------------------------------------------- setSeqString -----------
  void setSeqString (const std::string & seq);


  //--------------------------------------------------- operator++ -------------
  Kmer_t & operator++ (int)
  {
    count_m ++;
    return *this;
  }


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


  //--------------------------------------------------- operator= --------------
  Kmer_t & operator= (const Kmer_t & source);
};

} // namespace AMOS

#endif // #ifndef __Kmer_AMOS_HH

---