AccessibilityFromStream.h

Go to the documentation of this file.

 
#ifndef INTARNA_ACCESSIBILITYFROMSTREAM_H_
#define INTARNA_ACCESSIBILITYFROMSTREAM_H_
 
#include "IntaRNA/Accessibility.h"
 
#include <iostream>
 
#include "IntaRNA/Matrix.h"
 
namespace IntaRNA {
 
class AccessibilityFromStream: public Accessibility
{
public:
 
    enum InStreamType {
        Pu_RNAplfold_Text 
        , ED_RNAplfold_Text 
        , IntaRNA_Binary 
    };
 
public:
 
    AccessibilityFromStream(
            const RnaSequence& sequence
            , const size_t maxLength
            , const AccessibilityConstraint * const accConstraint
            , std::istream & inStream
            , const InStreamType inStreamType
            , const Z_type RT
            );
 
 
    virtual ~AccessibilityFromStream();
 
 
    virtual
    E_type
    getED( const size_t from, const size_t to ) const;
 
    virtual
    size_t
    getMaxLength() const;
 
 
    void writeBinary( std::ostream & out ) const override;
 
protected:
 
    typedef UpperBandedMatrix<E_type> EdMatrix;
 
    EdMatrix edValues;
 
    void parseBinary( std::istream & inStream );
 
    size_t availMaxLength;
 
    void
    parsePu_RNAplfold_text( std::istream & inStream, const Z_type RT );
 
 
    void
    parseED_RNAplfold_text( std::istream & inStream );
 
    void
    parseRNAplfold_text( std::istream & inStream
                        , const Z_type RT
                        , const bool parseProbs );
 
 
};
 
 
inline
void
AccessibilityFromStream::writeBinary( std::ostream & out ) const
{
    Accessibility::writeBinary(out, &edValues);
}
 
inline
E_type
AccessibilityFromStream::
getED( const size_t from, const size_t to ) const
{
    // input range check
    checkIndices(from,to);
 
    if ((to-from+1) <= getMaxLength()+1) { // "getMaxLength()+1" to allow for dangling-end probability computation
        // check for constrained end positions
        if (!getAccConstraint().isAccessible(from) || !getAccConstraint().isAccessible(to)) {
            // end position blocked --> omit accessibility
            return ED_UPPER_BOUND;
        }
        // return according ED value from the precomputed matrix
        return edValues (from,to);
    } else {
        // region length exceeds maximally allowed length -> no value
        return ED_UPPER_BOUND;
    }
}
 
 
inline
size_t
AccessibilityFromStream::
getMaxLength() const
{
    return availMaxLength;
}
 
 
inline
void
AccessibilityFromStream::
parsePu_RNAplfold_text( std::istream & inStream, const Z_type RT )
{
    parseRNAplfold_text( inStream, RT, true );
}
 
 
inline
void
AccessibilityFromStream::
parseED_RNAplfold_text( std::istream & inStream )
{
    parseRNAplfold_text( inStream, 1.0, false );
}
 
 
} // namespace
 
#endif /* ACCESSIBILITYFROMSTREAM_H_ */