src/LocARNA/params.hh

#ifndef LOCARNA_PARAMS_HH
#define LOCARNA_PARAMS_HH

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "scoring_fwd.hh"

#include <vector>
#include <string>

namespace LocARNA {

    class Scoring;
    class Sequence;
    class ArcMatches;
    class AnchorConstraints;
    class TraceController;
    class SparsificationMapper;

    class FreeEndgapsDescription {
        std::vector<bool> desc;

    public:
        explicit
        FreeEndgapsDescription(const std::string &d) : desc(4) {
            if (d.length() >= 4) {
                for (size_t i = 0; i < 4; i++)
                    desc[i] = (d[i] == '+');
            } else {
                for (size_t i = 0; i < 4; i++)
                    desc[i] = false;
            }
        }

        bool
        allow_left_1() const {
            return desc[0];
        }

        bool
        allow_right_1() const {
            return desc[1];
        }

        bool
        allow_left_2() const {
            return desc[2];
        }

        bool
        allow_right_2() const {
            return desc[3];
        }
    };

    class AlignerParams {
        friend class Aligner;
        friend class AlignerImpl;

    protected:
        const Sequence *seqA_; 

        const Sequence *seqB_; 

        const ArcMatches *arc_matches_; 

        const Scoring *scoring_; 

        bool no_lonely_pairs_; 

        bool struct_local_; 


        bool sequ_local_; 


        std::string
            free_endgaps_; 

        bool DO_TRACE_; 

        const TraceController *trace_controller_; 



        int max_diff_am_; 

        int max_diff_at_am_; 


        bool stacking_; 

        const AnchorConstraints *constraints_; 

    public:
        AlignerParams &
        seqA(const Sequence &seqA) {
            seqA_ = &seqA;
            return *this;
        }

        AlignerParams &
        seqB(const Sequence &seqB) {
            seqB_ = &seqB;
            return *this;
        }

        AlignerParams &
        arc_matches(const ArcMatches &arc_matches) {
            arc_matches_ = &arc_matches;
            return *this;
        }

        AlignerParams &
        scoring(const Scoring &scoring) {
            scoring_ = &scoring;
            return *this;
        }

        AlignerParams &
        no_lonely_pairs(bool no_lonely_pairs) {
            no_lonely_pairs_ = no_lonely_pairs;
            return *this;
        }

        AlignerParams &
        struct_local(bool struct_local) {
            struct_local_ = struct_local;
            return *this;
        }

        AlignerParams &
        sequ_local(bool sequ_local) {
            sequ_local_ = sequ_local;
            return *this;
        }

        AlignerParams &
        free_endgaps(const std::string &free_endgaps) {
            free_endgaps_ = free_endgaps;
            return *this;
        }

        AlignerParams &
        DO_TRACE(bool DO_TRACE) {
            DO_TRACE_ = DO_TRACE;
            return *this;
        }

        AlignerParams &
        trace_controller(const TraceController &trace_controller) {
            trace_controller_ = &trace_controller;
            return *this;
        }

        AlignerParams &
        max_diff_am(int max_diff_am) {
            max_diff_am_ = max_diff_am;
            return *this;
        }

        AlignerParams &
        max_diff_at_am(int max_diff_at_am) {
            max_diff_at_am_ = max_diff_at_am;
            return *this;
        }

        AlignerParams &
        stacking(bool stacking) {
            stacking_ = stacking;
            return *this;
        }

        AlignerParams &
        constraints(const AnchorConstraints &constraints) {
            constraints_ = &constraints;
            return *this;
        }

    protected:
        AlignerParams()
            : seqA_(0L),
              seqB_(0L),
              arc_matches_(0L),
              scoring_(0L),
              no_lonely_pairs_(false),
              struct_local_(false),
              sequ_local_(false),
              free_endgaps_(""),
              DO_TRACE_(true),
              trace_controller_(0L),
              max_diff_am_(-1),
              max_diff_at_am_(-1),
              stacking_(false),
              constraints_(0L) {}

    public:
        virtual ~AlignerParams();
    };

    class AlignerPParams : public AlignerParams {
        friend class AlignerP;

    protected:
        double min_am_prob_; 

        double min_bm_prob_; 

        pf_score_t pf_scale_; 

        AlignerPParams()
            : AlignerParams(),
              min_am_prob_(0),
              min_bm_prob_(0),
              pf_scale_((pf_score_t)1) {}

    public:
        AlignerPParams &
        min_am_prob(double min_am_prob) {
            min_am_prob_ = min_am_prob;
            return *this;
        }

        AlignerPParams &
        min_bm_prob(double min_bm_prob) {
            min_bm_prob_ = min_bm_prob;
            return *this;
        }

        AlignerPParams &
        pf_scale(pf_score_t pf_scale) {
            pf_scale_ = pf_scale;
            return *this;
        }

        ~AlignerPParams() {}
    };

    class AlignerNParams : public AlignerParams {
        friend class AlignerN;

    protected:
        const SparsificationMapper
            *sparsification_mapperA_; 
        const SparsificationMapper
            *sparsification_mapperB_; 

        AlignerNParams()
            : AlignerParams(),
              sparsification_mapperA_(0L),
              sparsification_mapperB_(0L) {}

    public:
        AlignerNParams &
        sparsification_mapperA(
            const SparsificationMapper &sparsification_mapperA) {
            sparsification_mapperA_ = &sparsification_mapperA;
            return *this;
        }

        AlignerNParams &
        sparsification_mapperB(
            const SparsificationMapper &sparsification_mapperB) {
            sparsification_mapperB_ = &sparsification_mapperB;
            return *this;
        }

        ~AlignerNParams() {}
    };
}

#endif // LOCARNA_PARAMS_HH