individual_field_iterator.h

Go to the documentation of this file.

#ifndef gamgee__individual_field_iterator__guard
#define gamgee__individual_field_iterator__guard 

#include "../utils/utils.h"

#include "htslib/vcf.h"

#include<iterator>

namespace gamgee {


template<class TYPE>
class IndividualFieldIterator : public std::iterator<std::random_access_iterator_tag, TYPE> {
 public:

  IndividualFieldIterator(const std::shared_ptr<bcf1_t>& body, bcf_fmt_t* format_ptr, bool end_iterator = false) :
    m_body {body}, 
    m_format_ptr {format_ptr},
    m_data_ptr {end_iterator ? format_ptr->p + m_format_ptr->size * m_body->n_sample : format_ptr->p} 
  {}

  IndividualFieldIterator(const IndividualFieldIterator& other) :
    m_body {other.m_body},
    m_format_ptr {other.m_format_ptr},
    m_data_ptr {other.m_data_ptr}
  {}
      
  IndividualFieldIterator(IndividualFieldIterator&& other) noexcept : 
    m_body {std::move(other.m_body)},
    m_format_ptr {other.m_format_ptr},
    m_data_ptr {other.m_data_ptr}
  {}

  IndividualFieldIterator& operator=(const IndividualFieldIterator& other) {
    m_body = other.m_body;
    m_format_ptr = other.m_format_ptr;
    m_data_ptr = other.m_data_ptr;
    return *this;
  }

  IndividualFieldIterator& operator=(IndividualFieldIterator&& other) noexcept {
    m_body = std::move(other.m_body);
    m_format_ptr = other.m_format_ptr;
    m_data_ptr = other.m_data_ptr;
    return *this;
  }

  IndividualFieldIterator& operator+=(const int n) noexcept {
    m_data_ptr += n * m_format_ptr->size;
    return *this;
  }

  IndividualFieldIterator& operator-=(const int n) noexcept {
    m_data_ptr -= n * m_format_ptr->size;
    return *this;
  }

  bool operator==(const IndividualFieldIterator& other) {
    return m_body == other.m_body && m_data_ptr == other.m_data_ptr;
  }

  bool operator!=(const IndividualFieldIterator& other) {
    return m_body != other.m_body || m_data_ptr != other.m_data_ptr;
  }

  bool operator<(const IndividualFieldIterator& other) {
    return m_body == other.m_body && m_data_ptr < other.m_data_ptr;
  }

  bool operator>(const IndividualFieldIterator& other) {
    return m_body == other.m_body && m_data_ptr > other.m_data_ptr;
  }

  bool operator<=(const IndividualFieldIterator& other) {
    return m_body == other.m_body && m_data_ptr <= other.m_data_ptr;
  }

  bool operator>=(const IndividualFieldIterator& other) {
    return m_body == other.m_body && m_data_ptr >= other.m_data_ptr;
  }

  TYPE operator*() const noexcept {
    return TYPE{m_body, m_format_ptr, m_data_ptr};
  }

  IndividualFieldIterator& operator++() noexcept {
    operator+=(1);
    return *this;
  }

  IndividualFieldIterator operator++(int) noexcept {
    auto const tmp = IndividualFieldIterator(*this);
    operator++();
    return tmp;
  }

  IndividualFieldIterator& operator--() noexcept {
    operator-=(1);
    return *this;
  }

  IndividualFieldIterator operator--(int) noexcept {
    auto const tmp = IndividualFieldIterator(*this);
    operator--();
    return tmp;
  }

  TYPE operator[](const uint32_t sample) const {
    uint32_t curr_sample_idx = (uint32_t)(((uint64_t)(m_data_ptr - m_format_ptr->p))/(m_format_ptr->size));
    utils::check_max_boundary(curr_sample_idx + sample, m_body->n_sample);
    return TYPE{m_body, m_format_ptr, m_data_ptr + (sample * m_format_ptr->size)};
  }

  int32_t  operator-(const IndividualFieldIterator<TYPE>& first) const {
    return static_cast<int32_t>(m_data_ptr - first.m_data_ptr)/m_format_ptr->size;
  }

 private:
  std::shared_ptr<bcf1_t> m_body;      
  bcf_fmt_t* m_format_ptr;         
  uint8_t* m_data_ptr;                 

};

}

#endif // gamgee__individual_field_iterator__guard