Read_AMOS.hh

Go to the documentation of this file.

#ifndef __Read_AMOS_HH
#define __Read_AMOS_HH 1

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




namespace AMOS {

typedef char ReadType_t;

//================================================ Read_t ======================
//==============================================================================
class Read_t : public Sequence_t
{

private:

  Range_t clear_m;                 
  ID_t frag_m;                     
  Range_t qclear_m;                
  ReadType_t type_m;               
  Range_t vclear_m;                
  std::vector<int16_t> bcp_m;      
  Pos_t pos_m;                     


protected:

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

  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 ReadType_t NULL_READ  = 0;
  static const ReadType_t OTHER      = 'X';
  static const ReadType_t END        = 'E';
  static const ReadType_t CONTIG     = 'C';
  static const ReadType_t BAC        = 'B';
  static const ReadType_t WALK       = 'W';
  static const ReadType_t TRANSPOSON = 'T';


  //--------------------------------------------------- Read_t -----------------
  Read_t ( )
  {
    frag_m = NULL_ID;
    type_m = NULL_READ;
    pos_m = 0;
  }


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


  //--------------------------------------------------- ~Read_t ----------------
  ~Read_t ( )
  {

  }


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


  //--------------------------------------------------- getBasePositions -------
  const std::vector<int16_t> & getBasePositions ( ) const
  {
    return bcp_m;
  }


  //--------------------------------------------------- getBasePositions -------
  std::vector<int16_t> & getBasePositions ( )
  {
    return bcp_m;
  }


  //--------------------------------------------------- getClearRange ----------
  Range_t getClearRange ( )
  {
    return clear_m;
  }


  //--------------------------------------------------- getFragment ------------
  ID_t getFragment ( ) const
  {
    return frag_m;
  }


  //--------------------------------------------------- getFragmentPosition ----
  Pos_t getFragmentPosition ( )
  {
    return pos_m;
  }


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


  //--------------------------------------------------- getQualityClearRange ---
  Range_t getQualityClearRange ( )
  {
    return qclear_m;
  }


  //--------------------------------------------------- getType ----------------
  ReadType_t getType ( ) const
  {
    return type_m;
  }


  //--------------------------------------------------- getVectorClearRange ----
  Range_t getVectorClearRange ( )
  {
    return vclear_m;
  }


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


  //--------------------------------------------------- setBasePositions -------
  void setBasePositions (const std::vector<int16_t> & bcp)
  {
    bcp_m = bcp;
  }


  //--------------------------------------------------- setClearRange ----------
  void setClearRange (Range_t clear)
  {
    clear_m = clear;
  }


  //--------------------------------------------------- setFragment ------------
  void setFragment (ID_t frag)
  {
    frag_m = frag;
  }


  //--------------------------------------------------- setFragmentPosition ----
  void setFragmentPosition (Pos_t pos)
  {
    pos_m = pos;
  }


  //--------------------------------------------------- setQualityClearRange ---
  void setQualityClearRange (Range_t qclear)
  {
    qclear_m = qclear;
  }


  //--------------------------------------------------- setType ----------------
  void setType (ReadType_t type);


  //--------------------------------------------------- setVectorClearRange ----
  void setVectorClearRange (Range_t vclear)
  {
    vclear_m = vclear;
  }


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

};


//================================================ Helper Functions ============
//----------------------------------------------------- operator<< -------------
std::ostream & operator<< (std::ostream & o, Read_t & read);

} // namespace AMOS

#endif // #ifndef __Read_AMOS_HH

---