mal_readonly.h

Go to the documentation of this file.

#ifndef MAL_READONLY_H_EA
#define MAL_READONLY_H_EA

/** @author Erik Arner, Karolinska Institute, (c) Erik Arner 2003.
    @version MAl version 0.1
*/

/** \brief MAl stands for Multiple Alignment, it is a container class
    for sequences in such an alignment.
    
    The idea is that this class should have "two" interfaces, one
    alignment/matrix interface with global indexes, columns etc and
    one sequence collection interface similar to the old cosmid
    interface.

    First version is a front end to the Berkeley DB. This could be
    made more flexible in future versions, allowing any storage of
    data using pImpl idiom.

    Problem: BDB has 1-based indexing (recno), while every algo
    written in the TRAP system uses 0-based indexing. I'll stick to
    0-based indexing in this system, to avoid future hassle.

    Future plans: make this system plugable along the same lines as
    the data classes in trapper, as the first implementation of the
    MAl class will be based on these classes. Also remove the coupling
    between this class and TrapperDoc...
*/

#include <set>
#include <vector>
#include "trapperdoc.h"//maybe fwd-decl instead??
#include "db_cxx.h"


//Public, global typedefs
typedef char base_t;
// typedef short int qual_t;
typedef Q_UINT32 qual_t;

class MAl_Readonly 
{
  
public:

  //'tors...
  MAl_Readonly(size_t bufsize, std::set<db_recno_t>& recnolist, TrapperDoc* pdoc);
  virtual ~MAl_Readonly();  


  void print_info(size_t ID) {
    cerr << "mal_readonly: print_info: ID = " << ID << endl;
    cerr << "get_seq_begin_global( ID ) = " << get_seq_begin_global( ID ) << endl;
    cerr << "get_seq_end_global( ID ) = " << get_seq_end_global( ID ) << endl;
    cerr << "get_len( ID ) = " << get_len( ID ) << endl;
  }

  //Common methods


  size_t get_num_seq();
  std::string get_name( size_t ID );
  std::string get_header( size_t ID );  
  std::string get_seq( size_t ID );
  std::string get_strand( size_t ID );
  size_t get_len( size_t ID);
  void select_read( size_t ID, bool status );

  //Separate interfaces

  size_t get_seq_row( size_t ID );

  size_t get_seq_begin( size_t ID );
  size_t get_seq_begin_global( size_t ID );

//   int get_seq_begin( size_t ID );//FIX THIS
//   int get_seq_begin_global( size_t ID );//FIX THIS

  size_t get_seq_end( size_t ID );
  size_t get_seq_end_global( size_t ID );

  size_t get_beginGood( size_t ID );
  size_t get_beginGood_global( size_t ID );

  size_t get_endGood( size_t ID );
  size_t get_endGood_global( size_t ID );

  base_t get_base( size_t ID, size_t index );
  base_t get_base_global( size_t ID, size_t index );

  qual_t get_qual( size_t ID, size_t index );
  qual_t get_qual_global( size_t ID, size_t index );

  bool is_DNP(size_t ID, size_t index);
  bool is_DNP_global(size_t ID, size_t index);

  int get_DNP_ID(size_t ID, size_t index);
  int get_DNP_ID_global(size_t ID, size_t index);

  int get_DNP_type(size_t ID, size_t index);
  int get_DNP_type_global(size_t ID, size_t index);
  
  double get_max_expression(size_t ID);
  size_t get_num_expression_points(size_t ID);
  double get_expression(size_t ID, size_t expression_index);

  template <typename Types>
  friend class MAlWrapper;

protected:
  //Protected methods
  size_t get_buffID(size_t ID);
  size_t next_buffID();
  
  virtual void flush_buffer(size_t buffID );
  void read_from_db(size_t buffID, size_t ID);
  void read_seq_from_db( db_recno_t recno, size_t buffID );
  void read_feat_from_db( db_recno_t recno, size_t buffID, const string& data_type_name);
  
  base_t comp_base(const char& base);

  //Protected structs

  struct dnp_struct
  {
    dnp_struct(bool is = false, db_recno_t rec = 0, int id = -1, int t = -1 ) :
      isDNP(is), recno(rec), ID(id), type(t) {}
    
    bool isDNP;
    db_recno_t recno;
    int ID;
    int type;
  };

  struct tag_struct
  {
    tag_struct(size_t sta = 0, size_t sto = 0, std::string ty = "", std::string at = "", db_recno_t rec = 0 ) : 
      start(sta), stop(sto), type(ty), attr(at), recno(rec) {}

    size_t start;
    size_t stop;
    std::string type;
    std::string attr;
    db_recno_t recno;

  };

  //Members
  size_t buff_size;
  size_t num_seq;
  TrapperDoc* doc;
  std::set<db_recno_t>& selectedReads;
  
  //Maybe use deques instead??
  //These guys are of the buffer size
  std::vector<std::vector<base_t> > seqs;
  std::vector<std::vector<qual_t> > quals;
  std::vector<std::vector<dnp_struct> > DNPs;
  std::vector<std::multimap<size_t, tag_struct> > tags;
  std::vector<std::vector<double> > time_course;

  std::vector<std::string> names;
  std::vector<std::string> headers;
  std::vector<std::string> mates;
  std::vector<std::string> strands;
  
  std::vector<size_t> seq_rows;
  std::vector<size_t> seq_begin_global;
  std::vector<size_t> seq_end_global;//Unnecessary?? We have the sizes of seqs...
  std::vector<size_t> seq_beginGood;//NB, not global!
  std::vector<size_t> seq_endGood;//NB, not global!
  std::vector<size_t> mate_lengths;

  //Buffer stuff
  vector<db_recno_t> ID_to_dbID;//Should be of actual data set size
  vector<size_t> ID_to_buffID;//Ditto
  vector<db_recno_t> buffID_to_dbID;//buffer size
  vector<db_recno_t> buffID_to_ID;//buffer size
  vector<bool> put_in_db;//Watch out for vector<bool>...
  

};


#endif //MAL_READONLY_H_EA
 


//Should this stuff be private??
/*
  void change_base( size_t ID, size_t baseIndex, char newBase );
  void set_seq_begin( size_t index, size_t pos );
  void set_beginGood( const size_t index, const size_t pos );
  void set_endGood( const size_t index, const size_t pos );
  void insert_base(size_t ID, size_t before_index, char base);  
  void remove_base(size_t ID, size_t index);  
  void put_qual( size_t ID, size_t qualValIndex, const size_t qualityValue );
  void delete_seq(size_t ID);
  bool is_deleted( size_t ID );
*/


//OBSOLETE???
/*
  std::string get_headerQ( size_t ID );
  size_t isPossibleRepeat(size_t ID);//????????????????????
  void mark_possibleRepeat(size_t ID);//??????????????????
  size_t append_seq( char seqName[], char seqHeader[] );
  size_t get_first_revComp_index();
  void set_max_coverage( size_t ID, size_t index, size_t cov );
  size_t get_max_coverage( size_t ID, size_t index );
  void set_pos_non_chimeric( size_t ID, size_t index);
  size_t is_chimeric( size_t ID, size_t index );
  void set_beginAnalyzable( const size_t index, const size_t pos );
  size_t get_beginAnalyzable( const size_t index );
  void set_endAnalyzable( const size_t index, const size_t pos );
  size_t get_endAnalyzable( const size_t index );  
  size_t get_number_seqs_in_file(const std::string fileName);
  size_t get_number_seqs_in_DATA_file(const std::string fileName);
  void set_qualBegin( const size_t index, const size_t pos );
  size_t get_qualBegin( const size_t index );
  void set_qualEnd( const size_t index, const size_t pos );
  size_t get_qualEnd( const size_t index );
  size_t is_quality( size_t index );
  void mark_is_quality(size_t id);
  size_t seq_size( size_t ID );
  size_t different_strands(size_t ID1, size_t ID2);
  size_t qual_size( size_t ID );
  char get_comp_base(char base);
  size_t get_ID_in_revComp_counterpart(size_t ID);
  size_t get_index_in_revComp_counterpart(size_t ID, size_t index);
  char get_DNP(size_t ID, size_t index);
  void set_DNP(size_t ID, size_t index, char base, size_t unique);
  void set_templ_DNP(size_t ID, size_t index);
  void set_templ_DNP_pos(size_t ID, size_t index, size_t pos);
  size_t is_templ_DNP(size_t ID, size_t index);
  size_t get_templ_DNP_pos(size_t ID, size_t index);
  void set_DNP_ncorr(size_t ID, size_t index, size_t ncorr);
  size_t get_DNP_ncorr(size_t ID, size_t index);
  void set_DNP_p(size_t ID, size_t index, double p);
  double get_DNP_p(size_t ID, size_t index);
  void set_DNP_against_insert(size_t ID, size_t index, char base, size_t unique);
  void set_DNP_against_deletion(size_t ID, size_t index, size_t unique, size_t unset_DNP);
  char get_DNP_against_insert(size_t ID, size_t index);
  char get_DNP_against_deletion(size_t ID, size_t index);
  size_t get_DNP_type(size_t ID, size_t index);
  size_t get_DNP_type_against_insert(size_t ID, size_t index);
  size_t get_DNP_type_against_deletion(size_t ID, size_t index);
  size_t DNP_mismatch(size_t ID, size_t index, char base);
  size_t DNP_mismatch_against_insert(size_t ID, size_t index, char base);
  size_t DNP_mismatch_against_deletion(size_t ID, size_t index);
*/

---