IndexRangeList.h

Go to the documentation of this file.

 
#ifndef INTARNA_INDEXRANGELIST_H_
#define INTARNA_INDEXRANGELIST_H_
 
#include "IntaRNA/IndexRange.h"
 
#include <list>
 
#include <boost/regex.hpp>
 
namespace IntaRNA {
 
class IndexRangeList
{
protected:
 
    typedef std::list< IndexRange > List;
 
public:
 
    static const std::string regexString;
 
    static const boost::regex regex;
 
public:
 
    typedef List::iterator iterator;
    typedef List::const_iterator const_iterator;
    typedef List::reverse_iterator reverse_iterator;
    typedef List::const_reverse_iterator const_reverse_iterator;
 
public:
 
    IndexRangeList( const bool allowOverlap = false );
 
    IndexRangeList( const std::string & stringEncoding
                    , const bool allowOverlap = false
                    , const RnaSequence * seq = NULL
                    , const bool isComplete = false );
 
    IndexRangeList( const IndexRangeList & toCopy );
 
 
    virtual ~IndexRangeList();
 
 
    bool covers( const size_t index ) const;
 
    bool covers( const size_t from, const size_t to ) const;
 
    bool covers( const IndexRange & range ) const;
 
    bool overlaps( const IndexRange& range ) const;
 
    void push_back( const IndexRange& range );
 
    iterator insert( const IndexRange& range );
 
    IndexRange & get( const size_t idx );
 
    const IndexRange & get( const size_t idx ) const;
 
    iterator erase( iterator i );
 
    iterator begin();
 
    iterator end();
 
    const_iterator begin() const;
 
    const_iterator end() const;
 
    reverse_iterator rbegin();
 
    reverse_iterator rend();
 
    const_reverse_iterator rbegin() const;
 
    const_reverse_iterator rend() const;
 
    bool empty() const;
 
    size_t size() const;
 
    void clear();
 
    bool isAllowingOverlap() const;
 
    void
    fromString( const std::string & stringEncoding, const RnaSequence * seq = NULL );
 
    IndexRangeList
    shift( const int indexShift, const size_t indexMax ) const;
 
    IndexRangeList &
    reverseInplace( const size_t seqLength );
 
    IndexRangeList
    reverse( const size_t seqLength ) const;
 
    const bool operator == ( const IndexRangeList &r ) const {
        return this->list == r.list;
    }
 
    const bool operator != ( const IndexRangeList &r ) const {
        return this->list != r.list;
    }
 
 
    friend std::ostream& operator<<(std::ostream& out, const IndexRangeList& l);
 
    void
    setComplete( const bool isComplete );
 
    bool
    isComplete() const;
 
protected:
 
    bool allowOverlap;
 
    List list;
 
    bool listIsComplete;
 
};
 
 
 
 
inline
IndexRangeList::IndexRangeList( const bool allowOverlap_ )
: allowOverlap(allowOverlap_)
, list()
, listIsComplete(false)
{
}
 
 
inline
IndexRangeList::IndexRangeList( const std::string & stringEncoding
                            , const bool allowOverlap_
                            , const RnaSequence * seq
                            , const bool isComplete )
: allowOverlap(allowOverlap_)
, list()
, listIsComplete(isComplete)
{
    fromString(stringEncoding, seq);
}
 
 
inline
IndexRangeList::IndexRangeList( const IndexRangeList & toCopy )
: allowOverlap(toCopy.allowOverlap)
, list(toCopy.list)
, listIsComplete(toCopy.listIsComplete)
{
}
 
 
inline
IndexRangeList::~IndexRangeList()
{
}
 
 
inline
void
IndexRangeList::setComplete( const bool isComplete )
{
    listIsComplete = isComplete;
}
 
 
inline
bool
IndexRangeList::isComplete() const
{
    return listIsComplete;
}
 
 
inline
bool
IndexRangeList::
covers( const size_t from, const size_t to ) const
{
    return covers( IndexRange(from, to) );
}
 
 
inline
IndexRangeList
IndexRangeList::
reverse( const size_t seqLength ) const
{
    // create copy
    IndexRangeList tmp(*this);
    // reverse and return copy
    return tmp.reverseInplace( seqLength );
}
 
 
inline
IndexRangeList::iterator IndexRangeList::erase( IndexRangeList::iterator i ) { 
    if (listIsComplete) {
        throw std::runtime_error("IndexRangeList::erase() : cannot erase from complete list");
    }
    return list.erase( i ); 
}
 
 
inline
IndexRangeList::iterator IndexRangeList::begin() { return list.begin(); }
 
 
inline
IndexRangeList::iterator IndexRangeList::end() { return list.end(); }
 
 
inline
IndexRangeList::const_iterator IndexRangeList::begin() const { return list.begin(); }
 
 
inline
IndexRangeList::const_iterator IndexRangeList::end() const { return list.end(); }
 
 
inline
IndexRangeList::reverse_iterator IndexRangeList::rbegin() { return list.rbegin(); }
 
 
inline
IndexRangeList::reverse_iterator IndexRangeList::rend() { return list.rend(); }
 
 
inline
IndexRangeList::const_reverse_iterator IndexRangeList::rbegin() const { return list.rbegin(); }
 
 
inline
IndexRangeList::const_reverse_iterator IndexRangeList::rend() const { return list.rend(); }
 
 
inline
bool IndexRangeList::empty() const { return list.empty(); }
 
 
inline
bool IndexRangeList::isAllowingOverlap() const { return allowOverlap; }
 
 
inline
size_t IndexRangeList::size() const { return list.size(); }
 
 
inline
void IndexRangeList::clear() { 
    listIsComplete = false;
    return list.clear(); 
}
 
 
inline
std::ostream& operator<<(std::ostream& out, const IndexRangeList& l)
{
    // output according to regex
    for (IndexRangeList::const_iterator i=l.begin(); i!=l.end(); i++)
        out <<(i==l.begin()?"":",") <<*i;
    return out;
}
 
 
 
} // namespace
 
#endif /* INDEXRANGELIST_H_ */