DualBarcodesPairedEndWithDiagnostics.hpp

Go to the documentation of this file.

#ifndef KAORI_DUAL_BARCODES_PAIRED_END_WITH_DIAGNOSTICS_HPP
#define KAORI_DUAL_BARCODES_PAIRED_END_WITH_DIAGNOSTICS_HPP
 
#include "DualBarcodesPairedEnd.hpp"
#include "CombinatorialBarcodesPairedEnd.hpp"
#include "../utils.hpp"
 
namespace kaori {
 
template<size_t max_size>
class DualBarcodesPairedEndWithDiagnostics { 
public:
    DualBarcodesPairedEndWithDiagnostics(
        const char* template_seq1, size_t template_length1, const BarcodePool& barcode_pool1,
        const char* template_seq2, size_t template_length2, const BarcodePool& barcode_pool2, 
        const typename DualBarcodesPairedEnd<max_size>::Options& options
    ) :
        dual_handler(template_seq1, template_length1, barcode_pool1, template_seq2, template_length2, barcode_pool2, options),
 
        combo_handler(
            template_seq1, 
            template_length1, 
            barcode_pool1, 
            template_seq2, 
            template_length2, 
            barcode_pool2, 
            [&]{
                typename CombinatorialBarcodesPairedEnd<max_size>::Options combopt;
                combopt.use_first = options.use_first;
 
                combopt.max_mismatches1 = options.max_mismatches1;
                combopt.strand1 = options.strand1;
                combopt.max_mismatches2 = options.max_mismatches2;
                combopt.strand2 = options.strand2;
 
                // we allow duplicates in the trie for each individual barcode, as only the pairs are unique in the dual barcode setup.
                combopt.duplicates = DuplicateAction::FIRST; 
                combopt.random = options.random;
                return combopt;
            }()
        )
    {}
 
private:
    DualBarcodesPairedEnd<max_size> dual_handler;
    CombinatorialBarcodesPairedEnd<max_size> combo_handler;
 
public:
    struct State {
        State() {}
        State(typename DualBarcodesPairedEnd<max_size>::State ds, typename CombinatorialBarcodesPairedEnd<max_size>::State cs) : dual_state(std::move(ds)), combo_state(std::move(cs)) {}
 
        typename DualBarcodesPairedEnd<max_size>::State dual_state;
        typename CombinatorialBarcodesPairedEnd<max_size>::State combo_state;
    };
 
    State initialize() const {
        return State(dual_handler.initialize(), combo_handler.initialize());
    }
 
    void reduce(State& s) {
        dual_handler.reduce(s.dual_state);
        combo_handler.reduce(s.combo_state);
    }
 
    constexpr static bool use_names = false;
public:
    void process(State& state, const std::pair<const char*, const char*>& r1, const std::pair<const char*, const char*>& r2) const {
        // Only searching for combinations if we couldn't find a proper dual barcode match.
        if (!dual_handler.process(state.dual_state, r1, r2)) {
            combo_handler.process(state.combo_state, r1, r2);
        }
    }
public:
    void sort() {
        combo_handler.sort();
    }
 
    const std::vector<int>& get_counts() const {
        return dual_handler.get_counts();
    }
 
    const std::vector<std::array<int, 2> >& get_combinations() const {
        return combo_handler.get_combinations();
    }
 
    int get_total() const {
        return dual_handler.get_total();
    }
 
    int get_barcode1_only() const {
        return combo_handler.get_barcode1_only();
    }
 
    int get_barcode2_only() const {
        return combo_handler.get_barcode2_only();
    }
};
 
// Soft-deprecated back-compatible aliases.
template<size_t max_size>
using DualBarcodesWithDiagnostics = DualBarcodesPairedEndWithDiagnostics<max_size>;
}
 
#endif