interval.h

Go to the documentation of this file.

#ifndef gamgee__interval__guard
#define gamgee__interval__guard

#include <vector>
#include <string>

namespace gamgee {

class Interval {
 public:

  enum class IntervalType {
      GATK,             
      PICARD,           
      BED               
  };

  Interval() :
    m_chr {0},
    m_start {0},
    m_stop {0},
    m_output_type {IntervalType::GATK}
  {}

  explicit Interval(const std::string& chr, const uint32_t start, const uint32_t stop, const IntervalType output_type = IntervalType::GATK) :
    m_chr{chr},
    m_start{start},
    m_stop{stop},
    m_output_type{output_type} 
  {}

  // it is good to be explicit about these defaults.
  Interval(const Interval&) = default;
  Interval(Interval&&) = default;
  Interval& operator=(const Interval&) = default;
  Interval& operator=(Interval&&) = default;

  bool operator==(const Interval& rhs) const;

  bool operator!=(const Interval& rhs) const { return !(*this == rhs); }

  inline uint32_t size() const { return m_stop - m_start + 1; }

  std::vector<Interval> tile_left(const uint32_t tile_size, 
                                  const uint32_t spacing    
                                  ) const;

  std::vector<Interval> tile_right(const uint32_t tile_size, 
                                   const uint32_t spacing    
                                  ) const;

  std::vector<Interval> tsca_tiling(const uint32_t spacing,     
                                    const uint32_t insert_size, 
                                    const uint32_t flanking     
                                   ) const;

  std::string str() const;    

  std::string chr() const                              { return m_chr;                }
  uint32_t start()  const                              { return m_start;              }
  uint32_t stop()   const                              { return m_stop;               }
  IntervalType output_type() const                     { return m_output_type;        }
  void set_chr(const std::string& chr)                 { m_chr = chr;                 }
  void set_start(const uint32_t start)                 { m_start = start;             }
  void set_stop(const uint32_t stop)                   { m_stop = stop;               }
  void set_output_type(const IntervalType output_type) { m_output_type = output_type; }

 private:
  std::string m_chr;           
  uint32_t m_start;            
  uint32_t m_stop;             
  IntervalType m_output_type;  

};

std::vector<Interval> read_intervals(const std::string& intervals_file);

std::vector<Interval> read_intervals(std::istream& input);

}  // end of namespace

std::ostream& operator<<(std::ostream&, const gamgee::Interval&);

#endif /* gamgee__interval__guard */