Overlap_AMOS.hh

Go to the documentation of this file.

#ifndef __Overlap_AMOS_HH
#define __Overlap_AMOS_HH 1

#include "Universal_AMOS.hh"




namespace AMOS {

typedef char OverlapAdjacency_t;

//================================================ Overlap_t ===================
//==============================================================================
class Overlap_t : public Universal_t
{

private:

  Size_t aHang_m;          
  Size_t bHang_m;          
  std::pair<ID_t, ID_t> reads_m;   
  uint32_t score_m;        


protected:

  static const uint8_t NORMAL_BITS     = 0x1;
  static const uint8_t ANTINORMAL_BITS = 0x2;
  static const uint8_t INNIE_BITS      = 0x3;
  static const uint8_t OUTIE_BITS      = 0x0;
  static const uint8_t ADJACENCY_BITS  = 0x3;  
  static const uint8_t ADJACENCY_BIT   = 0x4;  
  static const uint8_t FLAGC_BIT       = 0x8;  


  //--------------------------------------------------- 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 OverlapAdjacency_t NULL_ADJACENCY = 0;
  static const OverlapAdjacency_t NORMAL         = 'N';  
  static const OverlapAdjacency_t ANTINORMAL     = 'A';  
  static const OverlapAdjacency_t INNIE          = 'I';  
  static const OverlapAdjacency_t OUTIE          = 'O';  


  //--------------------------------------------------- Overlap_t --------------
  Overlap_t ( )
  {
    score_m = 0;
    aHang_m = bHang_m = 0;
    reads_m . first = reads_m . second = NULL_ID;
  }


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


  //--------------------------------------------------- ~Overlap_t -------------
  ~Overlap_t ( )
  {

  }


  //--------------------------------------------------- clear ------------------
  virtual void clear ( )
  {
    Universal_t::clear( );
    score_m = 0;
    aHang_m = bHang_m = 0;
    reads_m . first = reads_m . second = NULL_ID;
  }


  //--------------------------------------------------- flip -------------------
  void flip ( );


  //--------------------------------------------------- getAdjacency -----------
  OverlapAdjacency_t getAdjacency ( ) const;


  //--------------------------------------------------- getAhang ---------------
  Size_t getAhang ( ) const
  {
    return aHang_m;
  }


  //--------------------------------------------------- getBhang ---------------
  Size_t getBhang ( ) const
  {
    return bHang_m;
  }


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


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


  //--------------------------------------------------- getScore ---------------
  uint32_t getScore ( ) const
  {
    return score_m;
  }


  //--------------------------------------------------- isFlagC ----------------
  bool isFlagC ( ) const
  {
    return flags_m . nibble & FLAGC_BIT;
  }


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


  //--------------------------------------------------- setAdjacency -----------
  void setAdjacency (OverlapAdjacency_t adj);


  //--------------------------------------------------- setAhang ---------------
  void setAhang (Size_t aHang)
  {
    aHang_m = aHang;
  }


  //--------------------------------------------------- setBhang ---------------
  void setBhang (Size_t bHang)
  {
    bHang_m = bHang;
  }


  //--------------------------------------------------- setFlagC ---------------
  void setFlagC (bool flag)
  {
    if ( flag )
      flags_m . nibble |= FLAGC_BIT;
    else
      flags_m . nibble &= ~FLAGC_BIT;
  }


  //--------------------------------------------------- setReads ---------------
  void setReads (std::pair<ID_t, ID_t> reads)
  {
    reads_m = reads;
  }


  //--------------------------------------------------- setScore ---------------
  void setScore (uint32_t score)
  {
    score_m = score;
  }


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

};

} // namespace AMOS

#endif // #ifndef __Overlap_AMOS_HH

---