SingleBarcodeSingleEnd.hpp

Go to the documentation of this file.

#ifndef KAORI_SINGLE_BARCODE_SINGLE_END_HPP
#define KAORI_SINGLE_BARCODE_SINGLE_END_HPP
 
#include "../SimpleSingleMatch.hpp"
#include <vector>
 
namespace kaori {
 
template<SeqLength max_size_>
class SingleBarcodeSingleEnd {
public:
    struct Options {
        int max_mismatches = 0;
 
        bool use_first = true;
 
        SearchStrand strand = SearchStrand::FORWARD;
 
        DuplicateAction duplicates = DuplicateAction::ERROR;
    };
 
public:
    SingleBarcodeSingleEnd(const char* template_seq, SeqLength template_length, const BarcodePool& barcode_pool, const Options& options) :
        my_matcher(
            template_seq, 
            template_length,
            barcode_pool, 
            [&]{
                typename SimpleSingleMatch<max_size_>::Options ssopt;
                ssopt.strand = options.strand;
                ssopt.max_mismatches = options.max_mismatches;
                ssopt.duplicates = options.duplicates;
                return ssopt;
            }()
        ),
        my_counts(barcode_pool.size()),
        my_use_first(options.use_first) 
    {}
 
public:
    struct State {
        State() = default;
        State(typename SimpleSingleMatch<max_size_>::State s, typename std::vector<Count>::size_type nvar) : search(std::move(s)), counts(nvar) {}
 
        typename SimpleSingleMatch<max_size_>::State search;
        std::vector<Count> counts;
        Count total = 0;
    };
 
    void process(State& state, const std::pair<const char*, const char*>& x) const {
        bool found = false;
        if (my_use_first) {
            found = my_matcher.search_first(x.first, x.second - x.first, state.search);
        } else {
            found = my_matcher.search_best(x.first, x.second - x.first, state.search);
        }
        if (found) {
            ++(state.counts[state.search.index]);
        }
        ++state.total;
    }
 
    static constexpr bool use_names = false;
public:
    State initialize() const {
        return State(my_matcher.initialize(), my_counts.size());
    }
 
    void reduce(State& s) {
        my_matcher.reduce(s.search);
        for (decltype(my_counts.size()) i = 0, end = my_counts.size(); i < end; ++i) {
            my_counts[i] += s.counts[i];
        }
        my_total += s.total;
    }
private:
    SimpleSingleMatch<max_size_> my_matcher;
    std::vector<Count> my_counts;
    Count my_total = 0;
    bool my_use_first;
 
public:
    const std::vector<Count>& get_counts() const {
        return my_counts;        
    }
 
    Count get_total() const {
        return my_total;
    }
};
 
}
 
#endif