AccessibilityConstraint.h

Go to the documentation of this file.

 
#ifndef INTARNA_ACCESSIBILITYCONSTRAINT_H_
#define INTARNA_ACCESSIBILITYCONSTRAINT_H_
 
#include "IntaRNA/IndexRangeList.h"
#include "IntaRNA/RnaSequence.h"
 
#include <boost/regex.hpp>
 
#include <utility>
#include <vector>
 
namespace IntaRNA {
 
class AccessibilityConstraint {
 
public:
 
    static const char dotBracket_unconstrained;
    static const char dotBracket_blocked;
    static const char dotBracket_accessible;
    static const char dotBracket_paired;
 
    static const std::string dotBracket_constraints;
 
    static const std::string dotBracketAlphabet;
 
    static const std::string regionIndexList;
 
    static const boost::regex regex;
 
    static const boost::regex regexShapeMethod;
 
    static const boost::regex regexShapeConversion;
 
public:
 
    AccessibilityConstraint(  const size_t length
                            , const size_t maxBpSpan
                            , const std::string & shapeFile
                            , const std::string & shapeMethod
                            , const std::string & shapeConversion
                            );
 
    AccessibilityConstraint( const AccessibilityConstraint& toCopy
                        , const bool reverseIndices = false );
 
    AccessibilityConstraint( const RnaSequence & seq
                            , const std::string& dotBracket
                            , const size_t maxBpSpan
                            , const std::string & shapeFile
                            , const std::string & shapeMethod
                            , const std::string & shapeConversion
                            );
 
    virtual ~AccessibilityConstraint();
 
    bool
    isMarkedBlocked( const size_t i ) const;
 
    bool
    isMarkedAccessible( const size_t i ) const;
 
    bool
    isMarkedPaired( const size_t i ) const;
 
    bool
    isUnconstrained( const size_t i ) const;
 
    bool
    isAccessible( const size_t i ) const;
 
    bool
    isEmpty() const;
 
 
    char
    getVrnaDotBracket( const size_t i ) const;
 
    size_t
    getMaxBpSpan() const;
 
    const std::string &
    getShapeFile() const;
 
    const std::string &
    getShapeMethod() const;
 
    const std::string &
    getShapeConversion() const;
 
    AccessibilityConstraint & operator= ( const AccessibilityConstraint & c );
 
 
    friend std::ostream& operator<<(std::ostream& out, const AccessibilityConstraint& c);
 
protected:
 
    size_t length;
 
    size_t maxBpSpan;
 
    std::string shapeFile;
 
    std::string shapeMethod;
 
    std::string shapeConversion;
 
    IndexRangeList blocked;
 
    IndexRangeList accessible;
 
    IndexRangeList paired;
 
protected:
 
    static
    void
    screenDotBracket( const std::string& dotBracket
                    , const char marker
                    , IndexRangeList & storage );
 
};
 
 
std::ostream& operator<<(std::ostream& out, const AccessibilityConstraint& c);
 
 
 
inline
AccessibilityConstraint::
AccessibilityConstraint( const size_t length_
                    , const size_t maxBpSpan_
                    , const std::string & shapeFile_
                    , const std::string & shapeMethod_
                    , const std::string & shapeConversion_
                    )
    :
    length(length_),
    maxBpSpan( maxBpSpan_==0 ? length : std::min(maxBpSpan_,length) ),
    shapeFile(shapeFile_),
    shapeMethod(shapeFile_.empty() ? "" : shapeMethod_),
    shapeConversion(shapeFile_.empty() ? "" : shapeConversion_),
    blocked(),
    accessible(),
    paired()
{
#if INTARNA_IN_DEBUG_MODE
    if (!shapeFile.empty()) {
        if (!boost::regex_match( shapeMethod, AccessibilityConstraint::regexShapeMethod, boost::match_perl )) {
            throw std::runtime_error("AccessibilityConstraint(shapeMethod="+shapeMethod+") does not match its encoding regular expression");
        }
        if (!boost::regex_match( shapeConversion, AccessibilityConstraint::regexShapeConversion, boost::match_perl )) {
            throw std::runtime_error("AccessibilityConstraint(shapeConversion="+shapeConversion+") does not match its encoding regular expression");
        }
    }
#endif
}
 
 
inline
AccessibilityConstraint::
AccessibilityConstraint( const AccessibilityConstraint& toCopy
            , const bool reverseIndices)
    :
    length(toCopy.length)
    , maxBpSpan(toCopy.maxBpSpan)
    , shapeFile(toCopy.shapeFile)
    , shapeMethod(toCopy.shapeMethod)
    , shapeConversion(toCopy.shapeConversion)
    , blocked(toCopy.blocked)
    , accessible(toCopy.accessible)
    , paired(toCopy.paired)
{
 
 
    if (reverseIndices) {
 
        // reverse blocked
        blocked.reverseInplace(length);
 
        // reverse accessible
        accessible.reverseInplace(length);
 
        // reverse accessible
        paired.reverseInplace(length);
 
    }
}
 
 
inline
AccessibilityConstraint::~AccessibilityConstraint()
{
}
 
 
inline
bool
AccessibilityConstraint::
isMarkedBlocked(const size_t i) const
{
    return blocked.covers(i);
}
 
 
inline
bool
AccessibilityConstraint::
isMarkedAccessible(const size_t i) const
{
    return accessible.covers(i);
}
 
 
inline
bool
AccessibilityConstraint::
isMarkedPaired(const size_t i) const
{
    return paired.covers(i);
}
 
 
inline
bool
AccessibilityConstraint::
isUnconstrained( const size_t i ) const
{
    return isEmpty()
            || !(isMarkedAccessible(i) || isMarkedBlocked(i) || isMarkedPaired(i));
}
 
 
inline
bool
AccessibilityConstraint::
isAccessible( const size_t i ) const
{
    return isEmpty()
            || !(isMarkedBlocked(i) || isMarkedPaired(i));
}
 
 
inline
bool
AccessibilityConstraint::
isEmpty() const
{
    // check if any constrained regions given
    return (accessible.size() + blocked.size() + paired.size() + shapeFile.size()) == 0;
}
 
 
inline
char
AccessibilityConstraint::
getVrnaDotBracket(const size_t i) const
{
    // check if to be accessible or blocked (==unstructured)
    if (isMarkedAccessible(i) || isMarkedBlocked(i)) {
        return 'x';
    }
 
    // check if intramolecularly paired
    if (isMarkedPaired(i)) {
        return '|';
    }
 
    return '.';
}
 
 
inline
size_t
AccessibilityConstraint::
getMaxBpSpan() const
{
    return maxBpSpan;
}
 
 
inline
const std::string &
AccessibilityConstraint::
getShapeFile() const
{
    return shapeFile;
}
 
 
inline
const std::string &
AccessibilityConstraint::
getShapeMethod() const
{
    return shapeMethod;
}
 
 
inline
const std::string &
AccessibilityConstraint::
getShapeConversion() const
{
    return shapeConversion;
}
 
 
inline
AccessibilityConstraint &
AccessibilityConstraint::
operator= ( const AccessibilityConstraint & c )
{
    // copy data
    length = c.length;
    maxBpSpan = c.maxBpSpan;
    shapeFile = c.shapeFile;
    shapeMethod = c.shapeMethod;
    shapeConversion = c.shapeConversion;
    blocked = c.blocked;
    accessible = c.accessible;
    paired = c.paired;
 
    return *this;
}
 
 
inline
std::ostream& operator<<(std::ostream& out, const AccessibilityConstraint& c)
{
    bool alreadyPrinted = false;
    // print ranges if non-empty
    if (!c.accessible.empty()) {
        out <<(alreadyPrinted?",":"") <<AccessibilityConstraint::dotBracket_accessible <<':' <<c.accessible;
        alreadyPrinted = true;
    }
    // print ranges if non-empty
    if (!c.blocked.empty()) {
        out <<(alreadyPrinted?",":"") <<AccessibilityConstraint::dotBracket_blocked <<':' <<c.blocked;
        alreadyPrinted = true;
    }
    // print ranges if non-empty
    if (!c.paired.empty()) {
        out <<(alreadyPrinted?",":"") <<AccessibilityConstraint::dotBracket_paired <<':' <<c.paired;
        alreadyPrinted = true;
    }
    // print shape file if non-empty
    if (!c.shapeFile.empty()) {
        out <<(alreadyPrinted?",":"") <<"shapeFile" <<':' <<c.shapeFile;
        alreadyPrinted = true;
    }
    return out;
}
 
 
} // namespace
 
#endif /* ACCESSIBILITYCONSTRAINT_H_ */