SeedConstraint.h

Go to the documentation of this file.

 
#ifndef INTARNA_SEEDCONSTRAINT_H_
#define INTARNA_SEEDCONSTRAINT_H_
 
 
#include "IntaRNA/general.h"
#include "IntaRNA/IndexRangeList.h"
 
#include <cstddef>
#include <iostream>
 
namespace IntaRNA {
 
class SeedConstraint {
 
public:
 
    SeedConstraint(  const size_t bp
                , const size_t maxUnpairedOverall
                , const size_t maxUnpaired1
                , const size_t maxUnpaired2
                , const E_type maxE
                , const E_type maxED
                , const E_type maxEhybrid
                , const IndexRangeList & ranges1
                , const IndexRangeList & ranges2reversed
                , const std::string & explicitSeeds
                , const bool noGUallowed
                , const bool noGUendAllowed
                , const bool noLP
                );
 
    virtual ~SeedConstraint();
 
 
    size_t
    getBasePairs() const;
 
    size_t
    getMaxUnpairedOverall() const;
 
    size_t
    getMaxUnpaired1() const;
 
    size_t
    getMaxUnpaired2() const;
 
    E_type
    getMaxE() const;
 
    E_type
    getMaxED() const;
 
    E_type
    getMaxEhybrid() const;
 
    size_t
    getMaxLength1() const;
 
    size_t
    getMaxLength2() const;
 
    bool
    isGUallowed() const;
 
    bool
    isGUendAllowed() const;
 
    bool
    isLpAllowed() const;
 
    const IndexRangeList &
    getRanges1() const;
 
    const IndexRangeList &
    getRanges2() const;
 
    const std::string &
    getExplicitSeeds() const;
 
    IndexRangeList &
    getRanges1();
 
    IndexRangeList &
    getRanges2();
 
    std::string &
    getExplicitSeeds();
 
    friend std::ostream& operator<<(std::ostream& out, const SeedConstraint& c);
 
protected:
 
    size_t bp;
 
    size_t maxUnpairedOverall;
 
    size_t maxUnpaired1;
 
    size_t maxUnpaired2;
 
    E_type maxE;
 
    E_type maxED;
 
    E_type maxEhybrid;
 
    IndexRangeList ranges1;
 
    IndexRangeList ranges2;
 
    std::string explicitSeeds;
 
    bool bpGUallowed;
 
    bool bpGUendAllowed;
 
    bool lpAllowed;
 
};
 
 
 
inline
SeedConstraint::SeedConstraint(
         const size_t bp_
        , const size_t maxUnpairedOverall_
        , const size_t maxUnpaired1_
        , const size_t maxUnpaired2_
        , const E_type maxE_
        , const E_type maxED_
        , const E_type maxEhybrid
        , const IndexRangeList & ranges1
        , const IndexRangeList & ranges2reversed
        , const std::string & explicitSeeds
        , const bool noGUallowed
        , const bool noGUendAllowed
        , const bool noLP
        )
 :
      bp(bp_)
    , maxUnpairedOverall(maxUnpairedOverall_)
    , maxUnpaired1(std::min(maxUnpaired1_,maxUnpairedOverall_)) // exclude too large boundaries
    , maxUnpaired2(std::min(maxUnpaired2_,maxUnpairedOverall_)) // exclude too large boundaries
    , maxE(maxE_)
    , maxED(maxED_)
    , maxEhybrid(maxEhybrid)
    , ranges1(ranges1)
    , ranges2(ranges2reversed)
    , explicitSeeds(explicitSeeds)
    , bpGUallowed(!noGUallowed)
    , bpGUendAllowed(!noGUendAllowed)
    , lpAllowed(!noLP)
{
    if (bp < 2 && explicitSeeds.empty()) throw std::runtime_error("SeedConstraint() : base pair number ("+toString(bp)+") < 2");
}
 
 
inline
SeedConstraint::~SeedConstraint() {
}
 
 
inline
size_t
SeedConstraint::
getBasePairs() const {
    return bp;
}
 
 
inline
E_type
SeedConstraint::
getMaxE() const {
    return maxE;
}
 
 
inline
E_type
SeedConstraint::
getMaxED() const {
    return maxED;
}
 
 
inline
E_type
SeedConstraint::
getMaxEhybrid() const {
    return maxEhybrid;
}
 
 
inline
size_t
SeedConstraint::
getMaxUnpaired1() const {
    return maxUnpaired1;
}
 
 
inline
size_t
SeedConstraint::
getMaxUnpaired2() const {
    return maxUnpaired2;
}
 
 
inline
size_t
SeedConstraint::
getMaxUnpairedOverall() const {
    return maxUnpairedOverall;
}
 
 
inline
size_t
SeedConstraint::
getMaxLength1() const {
    return getBasePairs() + getMaxUnpaired1();
}
 
 
inline
size_t
SeedConstraint::
getMaxLength2() const {
    return getBasePairs() + getMaxUnpaired2();
}
 
 
inline
const IndexRangeList &
SeedConstraint::
getRanges1() const {
    return ranges1;
}
 
 
inline
const IndexRangeList &
SeedConstraint::
getRanges2() const {
    return ranges2;
}
 
 
inline
IndexRangeList &
SeedConstraint::
getRanges1() {
    return ranges1;
}
 
 
inline
IndexRangeList &
SeedConstraint::
getRanges2() {
    return ranges2;
}
 
 
inline
const std::string &
SeedConstraint::
getExplicitSeeds() const {
    return explicitSeeds;
}
 
 
inline
std::string &
SeedConstraint::
getExplicitSeeds() {
    return explicitSeeds;
}
 
 
inline
bool
SeedConstraint::
isGUallowed() const {
    return bpGUallowed;
}
 
 
inline
bool
SeedConstraint::
isGUendAllowed() const {
    return bpGUendAllowed;
}
 
 
inline
bool
SeedConstraint::
isLpAllowed() const {
    return lpAllowed;
}
 
 
inline
std::ostream&
operator<<(std::ostream& out, const SeedConstraint& c)
{
    out <<"SeedConstraint( bp="<<c.getBasePairs()
            <<", up="<<c.getMaxUnpairedOverall()
            <<", up1="<<c.getMaxUnpaired1()
            <<", up2="<<c.getMaxUnpaired2()
            <<", E="<<E_2_Ekcal(c.getMaxE())
            <<", ED="<<E_2_Ekcal(c.getMaxED())
            <<", Ehybrid="<<E_2_Ekcal(c.getMaxEhybrid())
            <<", noGU="<<(c.isGUallowed() ? "false":"true")
            <<", noGUend="<<(c.isGUendAllowed() ? "false":"true")
            <<")";
    return out;
}
 
 
} // namespace
 
#endif /* SEEDCONSTRAINT_H_ */