IndexRange.h

Go to the documentation of this file.

 
#ifndef INTARNA_INDEXRANGE_H_
#define INTARNA_INDEXRANGE_H_
 
 
#include "IntaRNA/general.h"
#include "IntaRNA/RnaSequence.h"
 
#include <stdexcept>
 
#include <boost/regex.hpp>
 
namespace IntaRNA {
 
class IndexRange {
 
public:
 
    static const size_t LAST_INDEX;
 
    static const size_t NA_INDEX;
 
    size_t from;
 
    size_t to;
 
    static constexpr const char* regexString = R"((0|-?[123456789]\d*)-(0|-?[123456789]\d*))";
 
    static const boost::regex regex;
 
public:
 
    IndexRange(const size_t from = 0,
            const size_t to = NA_INDEX)
        : from(from), to(to)
    {
    }
 
    IndexRange(const std::string & stringEncoding, const RnaSequence * seq )
        : from(0), to(NA_INDEX)
    {
        fromString(stringEncoding,seq);
    }
 
    virtual ~IndexRange() {}
 
    bool isAscending() const
    {
        return from <= to;
    }
 
    bool isDescending() const
    {
        return from >= to;
    }
 
    IndexRange operator + ( const int shift ) const {
        if (shift == 0) {
            return *this;
        }
        if (shift > 0) {
            return IndexRange(from+shift, to+shift);
        }
        if (to < std::abs(shift)) {
            return IndexRange( NA_INDEX, NA_INDEX);
        }
        return IndexRange( from - std::min(from, (size_t)std::abs(shift)), to + shift );
    }
 
    IndexRange operator - ( const int shift ) const {
        // forward implementation using inverted shift
        return this->operator+(-shift);
    }
 
    const bool operator < ( const IndexRange &r ) const {
        return ( from < r.from || (from==r.from && to<r.to) );
    }
 
    const bool operator == ( const IndexRange &r ) const {
        return ( from == r.from && to == r.to );
    }
 
    const bool operator != ( const IndexRange &r ) const {
        return !( this->operator ==(r) );
    }
 
 
    friend std::ostream& operator<<(std::ostream& out, const IndexRange& range)
    {
        // has to be in accordance to this.regex
        return (out <<range.from<<"-"<<range.to);
    }
 
    void
    fromString( const std::string & stringEncoding, const RnaSequence * seq )
    {
        if( ! boost::regex_match(stringEncoding, regex, boost::match_perl) ) {
            throw std::runtime_error("IndexRange::fromString("+stringEncoding+") uses no valid index range string encoding");
        }
        // find split position assuming second index to be negative
        size_t splitPos = stringEncoding.find("--");
        if (splitPos == std::string::npos) {
            // last index should not be negative, thus, split at last '-'
            splitPos = stringEncoding.find_last_of('-');
        }
        // parse interval boundaries
        if (seq == NULL) {
            from = boost::lexical_cast<size_t>(stringEncoding.substr(0,splitPos));
            to = boost::lexical_cast<size_t>(stringEncoding.substr(splitPos+1));
        } else {
            // correct for shifted indexing within the input sequence
            from = seq->getIndex(boost::lexical_cast<long>(stringEncoding.substr(0,splitPos)));
            to = seq->getIndex(boost::lexical_cast<long>(stringEncoding.substr(splitPos+1)));
        }
    }
    
    std::vector<IndexRange>
    overlappingWindows(const size_t windowWidth, const size_t windowOverlap) const;
    
    
};
 
} // namespace
 
#endif /* INDEXRANGE_H_ */