Interval.h

Go to the documentation of this file.

#ifndef INTERVAL_H
#define INTERVAL_H

#include <iostream>
#include <list>
#include <vector>
#include <cstdlib>

using namespace std;

class Interval {
   public:
      Interval() : b(-1), e(-1) { }
      Interval(const int bb, const int ee) : b(bb), e(ee) { }
      Interval(const Interval &iv) : b(iv.b), e(iv.e) { }
      Interval(const string &str);
      virtual ~Interval() { }

      friend ostream& operator<<(ostream& ous, const Interval& iv) {
         ous << iv.b << "-" << iv.e; return ous; }

      int overlap(const Interval &i) const;
      int overlap(const int bb, const int ee) const;
      virtual int merge(Interval *i, const int cut=5);
      virtual string toDelimitedString(const string &dl="\t") const;
      bool less(const Interval &iv) const { 
            return b<iv.b? true : (e<iv.e? true : false); }
      bool operator<(const Interval &iv) const { return less(iv); }
      bool before(const Interval &iv) const { return e < iv.b; }
      bool after(const Interval &iv) const { return b > iv.e; }
      bool isNull() const { return b==-1 && e==-1; }

      void setBegin(const int bb) { b=bb; }
      void setEnd(const int ee) { e=ee; }
      void set(const Interval &iv) { b=iv.b; e=iv.e; }
      int getBegin() const { return b; }
      int begin() const { return b; }
      int getEnd() const { return e; }
      int end() const { return e; }
      virtual int size() const { return 0; }
      int length() const { return e-b+1; }

   private:
      int b, e;
};

class IntervalPile : public Interval {
   public:
      IntervalPile() : Interval(), members() { }
      IntervalPile(Interval* ip) : Interval(*ip), members() { 
           members.push_back(ip); }
      ~IntervalPile();
      int merge(Interval *ip, const int cut=5);
      int add(Interval *i);
      int size() const { return members.size(); }
      string toDelimitedString(const string &dl="\t") const;

   protected:
      vector<Interval*> members;
};

class HalfAlignInterval : public Interval {
   public:
      HalfAlignInterval(const int bb, const int ee, int iden, int alen, float cc)
         : Interval(bb,ee), identical(iden), alnlen(alen), cov(cc) { }
      HalfAlignInterval(const HalfAlignInterval &i) 
         : Interval(i), identical(i.identical), alnlen(i.alnlen), cov(i.cov) { }
      int getIdentical() const { return identical; }
      float getIdentity() const { return static_cast<float>(identical)/alnlen; }
      int getAlnlen() const { return alnlen; }
      float getCov() const { return cov; }

   private:
      int identical; 
      int alnlen;
      float cov;
};

class HalfAlignPile : public IntervalPile {
   public:
      HalfAlignPile() : IntervalPile(), identity(-1.0), qcov(-1.0),
         tcov(-1.0) { }
      HalfAlignPile(const HalfAlignPile &p) 
         : IntervalPile(p), identity(p.identity), qcov(p.qcov) { }
      HalfAlignPile(HalfAlignInterval* hp) 
         : IntervalPile(hp), identity(-1.0), qcov(-1.0), tcov(-1.0) { }
      float getIdentity() const;
      float getCov() const { return getTcov(); }
      float getQcov() const;
      float getTcov() const;
      string toDelimitedString(const string &dl="\t") const;

   private:
      void computeIntermediateResult() const;
      mutable float identity;
      mutable float qcov;
      mutable float tcov;
};

/*

bool lessInterval(const Interval *iv1, const Interval *iv2) {
   return iv1->less(*iv2);
}
*/

class IntervalChain : public Interval {
   public:
      typedef list<Interval*>::iterator iterator;
      typedef list<Interval*>::const_iterator const_iterator;
      iterator begin() { return chain.begin(); }
      iterator end() { return chain.end(); }
      IntervalChain() : Interval(-1, -1), chain() { }

      IntervalChain(const int bb, const int ee) 
         : Interval(bb, ee), chain() { chain.push_back(new Interval(bb,ee));  }
      IntervalChain(const Interval &iv) : Interval(iv), chain()
         { chain.push_back(new Interval(iv)); }
      IntervalChain(Interval* iv) : Interval(*iv), chain() { chain.push_back(iv); }
      ~IntervalChain();

      void add(Interval *iv);
      void add(const int bb, const int ee);
      int size() const { return chain.size(); }
      /* output function */
      friend ostream& operator<<(ostream &ous, const IntervalChain &iv);

      int getInnerLength() const;
      int getOuterLength() const;

   private:
      //set<Interval*, lessInterval> chain;
      list<Interval*> chain;
};


#endif