DualBarcodesSingleEndWithDiagnostics.hpp

Go to the documentation of this file.

#ifndef KAORI_DUAL_BARCODES_SINGLE_END_WITH_DIAGNOSTICS_HPP
#define KAORI_DUAL_BARCODES_SINGLE_END_WITH_DIAGNOSTICS_HPP
 
#include "DualBarcodesSingleEnd.hpp"
#include "CombinatorialBarcodesSingleEnd.hpp"
#include "../utils.hpp"
 
namespace kaori {
 
template<SeqLength max_size_, int num_variable_>
class DualBarcodesSingleEndWithDiagnostics { 
public:
    DualBarcodesSingleEndWithDiagnostics(
        const char* template_seq, 
        SeqLength template_length, 
        const std::vector<BarcodePool>& barcode_pools, 
        const typename DualBarcodesSingleEnd<max_size_>::Options& options
    ) :
        my_dual_handler(
            template_seq,
            template_length,
            barcode_pools,
            options
        ),
        my_combo_handler(
            template_seq,
            template_length,
            barcode_pools, 
            [&]{
                typename CombinatorialBarcodesSingleEnd<max_size_, num_variable_>::Options combopt;
                combopt.use_first = options.use_first;
 
                combopt.max_mismatches = options.max_mismatches;
                combopt.strand = options.strand;
 
                // we allow duplicates in the trie for each individual barcode, as only the combinations are unique in the dual barcode setup.
                combopt.duplicates = DuplicateAction::FIRST; 
                return combopt;
            }()
        )
    {}
 
private:
    DualBarcodesSingleEnd<max_size_> my_dual_handler;
    CombinatorialBarcodesSingleEnd<max_size_, num_variable_> my_combo_handler;
 
public:
    struct State {
        State() {}
        State(typename DualBarcodesSingleEnd<max_size_>::State ds, typename CombinatorialBarcodesSingleEnd<max_size_, num_variable_>::State cs) :
            dual_state(std::move(ds)), combo_state(std::move(cs)) {}
 
        typename DualBarcodesSingleEnd<max_size_>::State dual_state;
        typename CombinatorialBarcodesSingleEnd<max_size_, num_variable_>::State combo_state;
    };
 
    State initialize() const {
        return State(my_dual_handler.initialize(), my_combo_handler.initialize());
    }
 
    void reduce(State& s) {
        my_dual_handler.reduce(s.dual_state);
        my_combo_handler.reduce(s.combo_state);
    }
 
    constexpr static bool use_names = false;
public:
    void process(State& state, const std::pair<const char*, const char*>& x) const {
        // Only searching for combinations if we couldn't find a proper dual barcode match.
        if (!my_dual_handler.process(state.dual_state, x)) {
            my_combo_handler.process(state.combo_state, x);
        }
    }
public:
    const std::vector<Count>& get_counts() const {
        return my_dual_handler.get_counts();
    }
 
    const std::unordered_map<std::array<BarcodeIndex, num_variable_>, Count, CombinationHash<num_variable_> >& get_combinations() const {
        return my_combo_handler.get_combinations();
    }
 
    Count get_total() const {
        return my_dual_handler.get_total();
    }
};
 
}
 
#endif