Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

MAlWrapper< alphabet > Class Template Reference

#include <MalWrapper.hpp>

Collaboration diagram for MAlWrapper< alphabet >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef char value_type
typedef value_type & reference
typedef Iterator< MAl > iterator

Public Member Functions

 MAlWrapper (MAl *mal)
size_t nrows ()
bool empty (int row)
void print_info (size_t r)
iterator begin (size_t r)
iterator end (size_t r)
void decrement_first_pos (size_t r)
void decrement_last_pos (size_t r)
void insert (size_t r, iterator pos, const value_type &v)
void erase (size_t r, iterator pos)
void move_read_left (size_t r, int steps)
void move_read_right (size_t r, int steps)
value_type operator() (size_t r, size_t pos_in_read)
void swap (size_t r, int first_pos, int last_pos, const std::string &new_read)
int first_pos (size_t r)
int last_pos (size_t r)
void adjust_last_pos (size_t r, int steps, int)
int getMinStartCol ()
int getMaxStopCol ()
int getMinStartCol (int realRow)
 Beräkna minsta startCol (beakta inte rad realRow).
int getMaxStopCol (int realRow)
 Beräkna största stopCol (beakta inte rad realRow).
void set_realign_in_band (bool b)
bool left_fixed (size_t r)
bool right_fixed (size_t r)
bool others_left_fixed (size_t r)
bool others_right_fixed (size_t r)
size_t nrows_global ()
void adjust_pos_right_of_band_border (int d, int band_border_right)
iterator begin_global (size_t r)
iterator end_global (size_t r)
int first_pos_global (size_t r)
int last_pos_global (size_t r)
int swap_substr (size_t r, std::string &other_read)
void swap_suffix (size_t r, int first_pos, int last_pos, std::string &other_read)
void swap_prefix (size_t r, int first_pos, int last_pos, std::string &other_read)
bool realign_in_band ()

Private Attributes

MAl * mal_
bool realign_in_band_

Detailed Description

template<typename alphabet>
class MAlWrapper< alphabet >

This class wraps the MAl class so that it can be used by Realigner.

Definition at line 79 of file MalWrapper.hpp.

Member Typedef Documentation

template<typename alphabet>
typedef Iterator<MAl> MAlWrapper< alphabet >::iterator
 

Definition at line 83 of file MalWrapper.hpp.

template<typename alphabet>
typedef value_type& MAlWrapper< alphabet >::reference
 

Definition at line 82 of file MalWrapper.hpp.

template<typename alphabet>
typedef char MAlWrapper< alphabet >::value_type
 

Definition at line 81 of file MalWrapper.hpp.

Constructor & Destructor Documentation

template<typename alphabet>
MAlWrapper< alphabet >::MAlWrapper (  MAl *  mal  )  [inline]
 

Definition at line 85 of file MalWrapper.hpp.

00085 : mal_(mal) {}

Member Function Documentation

template<typename alphabet>
void MAlWrapper< alphabet >::adjust_last_pos (  size_t  r,
int  steps,
int 
)  [inline]
 

Definition at line 229 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_end_global(), MAlWrapper< alphabet >::mal_, and MAl::set_seq_end_global().

00229                                                  {
00230     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) + steps);
00231   }

template<typename alphabet>
void MAlWrapper< alphabet >::adjust_pos_right_of_band_border (  int  d,
int  band_border_right
)  [inline]
 

Definition at line 300 of file MalWrapper.hpp.

00300 {}

template<typename alphabet>
iterator MAlWrapper< alphabet >::begin (  size_t  r  )  [inline]
 

Definition at line 103 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::first_pos(), and MAlWrapper< alphabet >::mal_.

Referenced by MAlWrapper< alphabet >::begin_global(), MAlWrapper< alphabet >::erase(), MAlWrapper< alphabet >::insert(), MAlWrapper< alphabet >::print_info(), and MAlWrapper< alphabet >::swap().

00103                            {
00104 //     cerr << "begin(): r = " << r << ", first_pos(r) = " << first_pos(r) << endl;
00105     return Iterator<MAl>(mal_, r, first_pos(r));
00106   }

template<typename alphabet>
iterator MAlWrapper< alphabet >::begin_global (  size_t  r  )  [inline]
 

Definition at line 302 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::begin().

00302 { return begin(r); }

template<typename alphabet>
void MAlWrapper< alphabet >::decrement_first_pos (  size_t  r  )  [inline]
 

Definition at line 113 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_begin_global(), MAlWrapper< alphabet >::mal_, MAlWrapper< alphabet >::realign_in_band_, and MAl::set_seq_begin_global().

00113                                      {
00114     assert(!realign_in_band_);
00115     mal_->set_seq_begin_global(r, mal_->get_seq_begin_global(r) - 1);    
00116   }

template<typename alphabet>
void MAlWrapper< alphabet >::decrement_last_pos (  size_t  r  )  [inline]
 

Definition at line 118 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_end_global(), MAlWrapper< alphabet >::mal_, MAlWrapper< alphabet >::realign_in_band_, and MAl::set_seq_end_global().

00118                                     {
00119     assert(!realign_in_band_);
00120     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) - 1);    
00121   }

template<typename alphabet>
bool MAlWrapper< alphabet >::empty (  int  row  )  [inline]
 

Definition at line 89 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::first_pos(), MAlWrapper< alphabet >::last_pos(), and MAlWrapper< alphabet >::nrows().

00089                       {
00090     assert(0 <= row && row < static_cast<int>(nrows()));
00091     return (last_pos(row) == first_pos(row) - 1);
00092   }

template<typename alphabet>
iterator MAlWrapper< alphabet >::end (  size_t  r  )  [inline]
 

Definition at line 108 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::last_pos(), and MAlWrapper< alphabet >::mal_.

Referenced by MAlWrapper< alphabet >::end_global(), MAlWrapper< alphabet >::print_info(), and MAlWrapper< alphabet >::swap().

00108                          {
00109 //     cerr << "end(): r = " << r << ", last_pos(r) = " << last_pos(r) << endl;
00110     return Iterator<MAl>(mal_, r, last_pos(r) + 1);
00111   }

template<typename alphabet>
iterator MAlWrapper< alphabet >::end_global (  size_t  r  )  [inline]
 

Definition at line 303 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::end().

00303 { return end(r); }

template<typename alphabet>
void MAlWrapper< alphabet >::erase (  size_t  r,
iterator  pos
)  [inline]
 

Definition at line 135 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::first_pos(), MAl_Readonly::get_seq_end_global(), MAlWrapper< alphabet >::mal_, MAl::remove_gap_global(), and MAl::set_seq_end_global().

00135                                      {
00136     assert(operator()(r, pos - begin(r) == '-'));
00137     mal_->remove_gap_global(r, pos - begin(r) + first_pos(r));
00138 
00139     // Correct last_pos:
00140     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) + 1);
00141   }

template<typename alphabet>
int MAlWrapper< alphabet >::first_pos (  size_t  r  )  [inline]
 

Definition at line 223 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_begin_global(), and MAlWrapper< alphabet >::mal_.

Referenced by MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::empty(), MAlWrapper< alphabet >::erase(), MAlWrapper< alphabet >::first_pos_global(), MAlWrapper< alphabet >::getMinStartCol(), and MAlWrapper< alphabet >::insert().

00223 { return mal_->get_seq_begin_global(r); }

template<typename alphabet>
int MAlWrapper< alphabet >::first_pos_global (  size_t  r  )  [inline]
 

Definition at line 304 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::first_pos().

00304 { return first_pos(r); }

template<typename alphabet>
int MAlWrapper< alphabet >::getMaxStopCol (  int  realRow  )  [inline]
 

Beräkna största stopCol (beakta inte rad realRow).

Definition at line 264 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::last_pos(), and MAlWrapper< alphabet >::nrows().

00264                                  {
00265     int m = std::numeric_limits<int>::min();
00266     assert(nrows() > 0);
00267 
00268     for (size_t r = 0; r < nrows(); ++r) {
00269       if (static_cast<int>(r) != realRow)
00270         m = std::max(m, last_pos(r));
00271     }
00272     return m;
00273   }

template<typename alphabet>
int MAlWrapper< alphabet >::getMaxStopCol (   )  [inline]
 

Definition at line 243 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::last_pos(), and MAlWrapper< alphabet >::nrows().

00243                       {
00244     int m = std::numeric_limits<int>::min();
00245     assert(nrows() > 0);
00246     for (size_t r = 0; r < nrows(); ++r) {
00247         m = std::max(m, last_pos(r));
00248     }
00249     return m;
00250   }

template<typename alphabet>
int MAlWrapper< alphabet >::getMinStartCol (  int  realRow  )  [inline]
 

Beräkna minsta startCol (beakta inte rad realRow).

Definition at line 252 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::first_pos(), and MAlWrapper< alphabet >::nrows().

00252                                   {
00253     int m = std::numeric_limits<int>::max();
00254     assert(nrows() > 0);
00255 
00256     for (size_t r = 0; r < nrows(); ++r) {
00257       if (static_cast<int>(r) != realRow)
00258         m = std::min(m, first_pos(r));
00259     }
00260     return m;
00261   }

template<typename alphabet>
int MAlWrapper< alphabet >::getMinStartCol (   )  [inline]
 

Definition at line 235 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::first_pos(), and MAlWrapper< alphabet >::nrows().

00235                        {
00236     int m = std::numeric_limits<int>::max();
00237     assert(nrows() > 0);
00238     for (size_t r = 0; r < nrows(); ++r) {
00239       m = std::min(m, first_pos(r));
00240     }
00241     return m;
00242   }

template<typename alphabet>
void MAlWrapper< alphabet >::insert (  size_t  r,
iterator  pos,
const value_type &  v
)  [inline]
 

Definition at line 124 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::first_pos(), MAl_Readonly::get_seq_end_global(), MAl::insert_gap_global(), MAlWrapper< alphabet >::mal_, and MAl::set_seq_end_global().

00124                                                             {
00125     assert(v == '-');
00126 
00127     // NB: last_pos is already updated!!! 
00128     mal_->insert_gap_global(r, pos - begin(r) + first_pos(r));
00129 
00130     // Correct last_pos:
00131     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) - 1);
00132   }

template<typename alphabet>
int MAlWrapper< alphabet >::last_pos (  size_t  r  )  [inline]
 

Definition at line 224 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_end_global(), and MAlWrapper< alphabet >::mal_.

Referenced by MAlWrapper< alphabet >::empty(), MAlWrapper< alphabet >::end(), MAlWrapper< alphabet >::getMaxStopCol(), and MAlWrapper< alphabet >::last_pos_global().

00224 { return mal_->get_seq_end_global(r) - 1; }

template<typename alphabet>
int MAlWrapper< alphabet >::last_pos_global (  size_t  r  )  [inline]
 

Definition at line 305 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::last_pos().

00305 { return last_pos(r); }

template<typename alphabet>
bool MAlWrapper< alphabet >::left_fixed (  size_t  r  )  [inline]
 

Definition at line 281 of file MalWrapper.hpp.

00281                             { 
00282     return false;
00283     //    return (realign_in_band_ ? left_fixed_[r] : false); 
00284   }

template<typename alphabet>
void MAlWrapper< alphabet >::move_read_left (  size_t  r,
int  steps
)  [inline]
 

Definition at line 144 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_begin_global(), MAl_Readonly::get_seq_end_global(), MAlWrapper< alphabet >::mal_, MAl::set_seq_begin_global(), and MAl::set_seq_end_global().

00144                                            {
00145     assert(steps > 0);
00146 
00147     mal_->set_seq_begin_global(r, mal_->get_seq_begin_global(r) - steps);
00148     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) - steps);
00149   }

template<typename alphabet>
void MAlWrapper< alphabet >::move_read_right (  size_t  r,
int  steps
)  [inline]
 

Definition at line 152 of file MalWrapper.hpp.

References MAl_Readonly::get_seq_begin_global(), MAl_Readonly::get_seq_end_global(), MAlWrapper< alphabet >::mal_, MAl::set_seq_begin_global(), and MAl::set_seq_end_global().

00152                                             {
00153     assert(steps > 0);
00154 
00155     mal_->set_seq_begin_global(r, mal_->get_seq_begin_global(r) + steps);
00156     mal_->set_seq_end_global(r, mal_->get_seq_end_global(r) + steps);
00157   }

template<typename alphabet>
size_t MAlWrapper< alphabet >::nrows (   )  [inline]
 

Definition at line 87 of file MalWrapper.hpp.

References MAl_Readonly::get_num_seq(), and MAlWrapper< alphabet >::mal_.

Referenced by MAlWrapper< alphabet >::empty(), MAlWrapper< alphabet >::getMaxStopCol(), MAlWrapper< alphabet >::getMinStartCol(), and MAlWrapper< alphabet >::nrows_global().

00087 { return mal_->get_num_seq(); }

template<typename alphabet>
size_t MAlWrapper< alphabet >::nrows_global (   )  [inline]
 

Definition at line 299 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::nrows().

00299 { return nrows(); }

template<typename alphabet>
value_type MAlWrapper< alphabet >::operator() (  size_t  r,
size_t  pos_in_read
)  [inline]
 

Definition at line 159 of file MalWrapper.hpp.

References MAl_Readonly::get_base(), and MAlWrapper< alphabet >::mal_.

00159                                                       {
00160     // Remark: pos_in_read is local!
00161     return mal_->get_base(r, pos_in_read);
00162   }

template<typename alphabet>
bool MAlWrapper< alphabet >::others_left_fixed (  size_t  r  )  [inline]
 

Definition at line 289 of file MalWrapper.hpp.

00289                                    { 
00290     return false;
00291 //   assert(realign_in_band_);
00292 //     return others_left_fixed_[r]; }
00293   }

template<typename alphabet>
bool MAlWrapper< alphabet >::others_right_fixed (  size_t  r  )  [inline]
 

Definition at line 294 of file MalWrapper.hpp.

00294                                     {       
00295     return false;
00296 //     assert(realign_in_band_);
00297 //     return others_right_fixed_[r]; }
00298   }

template<typename alphabet>
void MAlWrapper< alphabet >::print_info (  size_t  r  )  [inline]
 

Definition at line 94 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::end(), MAlWrapper< alphabet >::mal_, and MAl_Readonly::print_info().

00094                             {
00095     mal_->print_info(r);    
00096     cerr << "In the wrapper: r = " << r << endl;
00097     cerr << "end(r) - begin(r) = " << (end(r) - begin(r)) << endl;
00098 //     cerr << "Info for row " << r << endl;
00099 //     cerr << "first_pos(r) = " << first_pos(r) << endl;
00100 //     cerr << "last_pos(r) = " << last_pos(r) << endl;
00101   }

template<typename alphabet>
bool MAlWrapper< alphabet >::realign_in_band (   )  [inline]
 

Definition at line 309 of file MalWrapper.hpp.

00309 { return false; }

template<typename alphabet>
bool MAlWrapper< alphabet >::right_fixed (  size_t  r  )  [inline]
 

Definition at line 285 of file MalWrapper.hpp.

00285                              {     
00286     return false;
00287     //    return (realign_in_band_ ? right_fixed_[r] : false); 
00288   }

template<typename alphabet>
void MAlWrapper< alphabet >::set_realign_in_band (  bool  b  )  [inline]
 

Definition at line 275 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::realign_in_band_.

00275                                    { 
00276 
00277     realign_in_band_ = b;
00278     if (b) { std::cerr << "realign in band not implemented yet" << endl; exit(1); }
00279     
00280   }

template<typename alphabet>
void MAlWrapper< alphabet >::swap (  size_t  r,
int  first_pos,
int  last_pos,
const std::string &  new_read
)  [inline]
 

Swap the supplied new_read with the (whole) read r.

Definition at line 167 of file MalWrapper.hpp.

References MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::end(), MAl::insert_gap(), MAlWrapper< alphabet >::mal_, MAl::remove_gap(), MAl::set_seq_begin_global(), and MAl::set_seq_end_global().

00167                                                                                {
00168     // check consistency of indata
00169     assert(last_pos + 1 - first_pos == static_cast<int>(new_read.size()));
00170 
00171     // check that new_read equals read r (except for gaps)
00172     assert(( al::equal_without_gaps<alphabet, alphabet>(begin(r), end(r),
00173                                                                         new_read.begin(), new_read.end())));
00174     // check that first or last character of new_read is not gap (just to be sure)
00175     assert(alphabet::isNotAbsGap(new_read[0]) && 
00176            alphabet::isNotAbsGap(new_read[new_read.size() - 1]));
00177 
00178     // get instructions
00179     vector<al::instr_value_type> instr;
00180     al::get_instructions<alphabet, alphabet>(begin(r), end(r), 
00181                                                              new_read.begin(), new_read.end(), 
00182                                                              back_inserter(instr));
00183     // update read r according to the instructions
00184     int pos = 0;
00185     for (unsigned i = 0; i < instr.size(); ++i) {
00186       pos += instr[i].first;
00187       switch(instr[i].second) {
00188       case al::DELETE_GAP:
00189         assert(alphabet::isAbsGap((*this)(r, pos)));
00190         mal_->remove_gap(r, pos);
00191         break;
00192       case al::INSERT_GAP:
00193         mal_->insert_gap(r, pos);
00194         ++pos;
00195         break;
00196       }
00197     }
00198 
00199     // set global begin and end
00200     mal_->set_seq_begin_global(r, first_pos);
00201     mal_->set_seq_end_global(r, first_pos + new_read.size());
00202 
00203     // check that the modified read r is equals new_read 
00204     if ( new_read.end() - new_read.begin() != end(r) - begin(r) ) {
00205       std::cerr << "new_read.end() - new_read.begin() = " << new_read.end() - new_read.begin() << endl;
00206       std::cerr << "begin(r) - end(r) = " << begin(r) - end(r) << endl;
00207     }
00208     assert( new_read.end() - new_read.begin() == end(r) - begin(r) );
00209     if ( !equal(new_read.begin(), new_read.end(), begin(r)) ) {
00210       al::print_elements_cerr(new_read, "", "new_read\n");
00211       al::print_elements_cerr(begin(r), end(r), "", "modified row r\n");
00212     }
00213     assert( std::equal(new_read.begin(), new_read.end(), begin(r)) );
00214                   
00215 //     mal_->set_seq_end(r, new_read.size() - 1);
00216 
00217 //     // write new sequence
00218 //     for (size_t i = 0; i < new_read.size(); ++i) {
00219 //       mal_->set_base(r, i, new_read[i]);
00220 //     }
00221   }

template<typename alphabet>
void MAlWrapper< alphabet >::swap_prefix (  size_t  r,
int  first_pos,
int  last_pos,
std::string &  other_read
)  [inline]
 

Definition at line 308 of file MalWrapper.hpp.

00308 { exit(0); }

template<typename alphabet>
int MAlWrapper< alphabet >::swap_substr (  size_t  r,
std::string &  other_read
)  [inline]
 

Definition at line 306 of file MalWrapper.hpp.

00306 { exit(0); }

template<typename alphabet>
void MAlWrapper< alphabet >::swap_suffix (  size_t  r,
int  first_pos,
int  last_pos,
std::string &  other_read
)  [inline]
 

Definition at line 307 of file MalWrapper.hpp.

00307 { exit(0); }

Member Data Documentation

template<typename alphabet>
MAl* MAlWrapper< alphabet >::mal_ [private]
 

Definition at line 312 of file MalWrapper.hpp.

Referenced by MAlWrapper< alphabet >::adjust_last_pos(), MAlWrapper< alphabet >::begin(), MAlWrapper< alphabet >::decrement_first_pos(), MAlWrapper< alphabet >::decrement_last_pos(), MAlWrapper< alphabet >::end(), MAlWrapper< alphabet >::erase(), MAlWrapper< alphabet >::first_pos(), MAlWrapper< alphabet >::insert(), MAlWrapper< alphabet >::last_pos(), MAlWrapper< alphabet >::move_read_left(), MAlWrapper< alphabet >::move_read_right(), MAlWrapper< alphabet >::nrows(), MAlWrapper< alphabet >::operator()(), MAlWrapper< alphabet >::print_info(), and MAlWrapper< alphabet >::swap().

template<typename alphabet>
bool MAlWrapper< alphabet >::realign_in_band_ [private]
 

Definition at line 313 of file MalWrapper.hpp.

Referenced by MAlWrapper< alphabet >::decrement_first_pos(), MAlWrapper< alphabet >::decrement_last_pos(), and MAlWrapper< alphabet >::set_realign_in_band().

The documentation for this class was generated from the following file:
Generated on Fri Mar 17 17:44:59 2006 for trapper by  doxygen 1.4.4