HelixConstraint.h

Go to the documentation of this file.

 
#ifndef INTARNA_HELIXCONSTRAINT_H
#define INTARNA_HELIXCONSTRAINT_H
 
#include "IntaRNA/general.h"
#include "IntaRNA/IndexRangeList.h"
 
#include <cstddef>
#include <iostream>
 
namespace IntaRNA {
 
class HelixConstraint {
 
public:
 
    HelixConstraint( const size_t minBP
                , const size_t maxBP
                , const size_t maxIL
                , const E_type maxED
                , const E_type maxE
                , const bool noED
                );
 
    virtual ~HelixConstraint();
 
    size_t
    getMinBasePairs() const;
 
    size_t
    getMaxBasePairs() const;
 
    size_t
    getMaxIL() const;
 
    E_type
    getMaxED() const;
 
    E_type
    getMaxE() const;
 
    bool
    evalFullE() const;
 
    size_t
    getMinInternalLoopSize() const;
 
    size_t
    getMaxLength1() const;
 
    size_t
    getMaxLength2() const;
 
    friend std::ostream& operator<<(std::ostream& out, const HelixConstraint& c);
 
protected:
 
    size_t minBP;
 
    size_t maxBP;
 
    size_t maxIL;
 
    E_type maxED;
 
    E_type maxE;
 
    bool checkFullE;
};
 
 
 
inline
HelixConstraint::HelixConstraint(
        const size_t minBP_
        , const size_t maxBP_
        , const size_t maxIL_
        , const E_type maxED_
        , const E_type maxE_
        , const bool checkFullE_)
    :
        minBP(minBP_)
      , maxBP(maxBP_)
      , maxIL(maxIL_)
      , maxED(maxED_)
      , maxE(maxE_)
      , checkFullE(checkFullE_)
{
    if (minBP < 2) throw std::runtime_error("HelixConstraint() : minimal base pair number ("+toString(minBP)+") < 2");
}
 
 
inline
HelixConstraint::~HelixConstraint() {
}
 
 
inline
size_t
HelixConstraint::
getMinBasePairs() const {
    return minBP;
}
 
 
inline
size_t
HelixConstraint::
getMaxBasePairs() const {
    return maxBP;
}
 
 
inline
size_t
HelixConstraint::
getMaxIL() const {
    return maxIL;
}
 
 
inline
E_type
HelixConstraint::
getMaxED() const {
    return maxED;
}
 
 
inline
E_type
HelixConstraint::
getMaxE() const {
    return maxE;
}
 
 
inline
bool
HelixConstraint::
evalFullE() const {
    return checkFullE;
}
 
 
inline
size_t
HelixConstraint::
getMaxLength1() const {
    return getMaxBasePairs() + (getMaxBasePairs()-1) * getMaxIL();
}
 
 
inline
size_t
HelixConstraint::
getMaxLength2() const {
    return getMaxBasePairs() + (getMaxBasePairs()-1) * getMaxIL();
}
 
 
inline
size_t
HelixConstraint::
getMinInternalLoopSize() const {
    return getMaxIL();
}
 
 
inline
std::ostream&
operator<<(std::ostream& out, const HelixConstraint& c)
{
    out <<"HelixConstraint( minBP="<<c.getMinBasePairs()
            <<", maxBP="<<c.getMaxBasePairs()
            <<", maxIL="<<c.getMaxIL()
            <<", maxED="<<E_2_Ekcal(c.getMaxED())
            <<", maxE="<<E_2_Ekcal(c.getMaxE())
            <<", evalFullE="<<(c.evalFullE()?"true":"false")
            <<")";
    return out;
 
}
 
 
} // namespace
 
#endif //INTARNA_HELIXCONSTRAINT_H