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_; 

        double min_am_prob_; 

        double min_bm_prob_;  
    
        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 &
        min_am_prob(double min_am_prob) {min_am_prob_=min_am_prob; return *this;}

        AlignerParams &
        min_bm_prob(double min_bm_prob) {min_bm_prob_=min_bm_prob; 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),
            min_am_prob_(0), 
            min_bm_prob_(0),       
            stacking_(false),
            constraints_(0L)
        {}

    public:
        virtual
        ~AlignerParams();
    };


    class AlignerPParams: public AlignerParams {  
        friend class AlignerP;

    protected:
        pf_score_t pf_scale_; 

        AlignerPParams()
            : AlignerParams(),
              pf_scale_((pf_score_t)1)
        {}

    public:
        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