me_battery.hpp

Go to the documentation of this file.

#ifndef ME_BATTERY_HPP_
#define ME_BATTERY_HPP_
#include <iosfwd>
#include <string>
#include <vector>

#include "me_aligned.hpp"
#include "me_ambiguous.hpp"
#include "me_combination.hpp"
#include "me_positional.hpp"
#include "me_short.hpp"
#include "me_truncate.hpp"
#include "me_types.hpp"
#include "sequence_map_types.hpp"
#include "vdj_pipe/exception.hpp"
#include "vdj_pipe/sequence_record.hpp"

namespace vdj_pipe{ namespace match{

class Match_element_visitor : public boost::static_visitor<sequence_interval> {
   typedef Seq_record::sequence sequence;
   typedef Qual_record::quality quality;
public:
   Match_element_visitor(
            sequence const& seq,
            quality const& qual
   )
   : seq_(seq), qual_(qual)
   {}

   void set_interval(sequence_interval const& si) {si_ = si;}

   template<class ME> sequence_interval operator()(ME& me) const {
      return me(seq_, qual_, si_);
   }

private:
   sequence const& seq_;
   quality const& qual_;
   sequence_interval si_;
};

class Match_element_battery {
   typedef Seq_record::sequence sequence;
   typedef Qual_record::quality quality;
public:
   struct Err : public base_exception{};

   Match_element_battery(
      variant_vector const& vv,
      truncate_vector const& tv,
      detail::string_vector const& names,
      detail::string_vector const& dep_names,
      std::vector<bool> const& is_required,
      combination_vector const& cv
   );

   std::size_t size() const {return mev_.size();}

   sequence_interval operator()(
            sequence const& seq,
            quality const& qual,
            sequence_interval const& si
   ) {
      //sequence intervals: input followed by ones generated by match elements
      interval_vector siv(size() + 1, sequence_interval_invalid());
      siv[0] = si;
      Match_element_visitor vis(seq, qual);
      sequence_interval trunc = sequence_interval::whole();
      for(std::size_t n = 0; n != mev_.size(); ++n) {
         //sequence interval to which current match element is defined relative to
         sequence_interval result = sequence_interval_invalid();
         sequence_interval const& dep = siv[me_deps_[n]];
         if( is_valid(dep) ) {
            //current match element will use the interval it depends on
            vis.set_interval(dep);
            result = boost::apply_visitor(vis, mev_[n]);
            siv[n + 1] = result;
            const sequence_interval trunc1 = tv_[n](result);
            trunc = intersect(trunc, trunc1);
         }
         if( required_[n] && ! is_valid(result) ) {
            trunc = sequence_interval::empty();
            ++n_removed_;
         }
      }

      for(std::size_t n = 0; n != cv_.size(); ++n) {
         cv_[n](seq, siv);
      }
      return trunc;
   }

   void finish();
   std::size_t n_removed() const {return n_removed_;}

private:
   variant_vector mev_;
   truncate_vector tv_;

   //for each match element indicate which other match element,
   //if any, it refers to
   std::vector<std::size_t> me_deps_;
   std::vector<bool> required_;
   combination_vector cv_;
   std::size_t n_removed_;
};

}//namespace match
}//namespace vdj_pipe
#endif /* ME_BATTERY_HPP_ */