shared_field_iterator.h

Go to the documentation of this file.

#ifndef gamgee__shared_field_iterator__guard
#define gamgee__shared_field_iterator__guard

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

#include "htslib/vcf.h"

#include <iterator>
#include <memory>

namespace gamgee {

template<class VALUE_TYPE>
class SharedFieldIterator : public std::iterator<std::random_access_iterator_tag, VALUE_TYPE> {
 public:

  SharedFieldIterator() : 
    m_body {nullptr},
    m_current_data_ptr {nullptr},
    m_original_data_ptr{nullptr},
    m_end_data_ptr{nullptr},
    m_bytes_per_value{0},
    m_type{utils::VariantFieldType::NIL},
    m_is_current_pointee_cached{false}
  {}
 
  explicit SharedFieldIterator(const std::shared_ptr<bcf1_t>& body, uint8_t* data_ptr, uint8_t* end_ptr, const uint8_t bytes_per_value, const utils::VariantFieldType& type) :
    m_body {body},
    m_current_data_ptr {data_ptr},
    m_original_data_ptr {data_ptr},
    m_end_data_ptr {end_ptr},
    m_bytes_per_value {bytes_per_value},
    m_type {type},
    m_is_current_pointee_cached{false}
  {}

  explicit SharedFieldIterator(const std::shared_ptr<bcf1_t>& body, uint8_t* data_ptr, const uint8_t bytes_per_value, const utils::VariantFieldType& type): SharedFieldIterator(body, data_ptr, nullptr, bytes_per_value, type)
  {}
   
  SharedFieldIterator(const SharedFieldIterator& other) = default; 
  SharedFieldIterator(SharedFieldIterator&& other) = default; 
  SharedFieldIterator& operator=(const SharedFieldIterator& other) = default;  
  SharedFieldIterator& operator=(SharedFieldIterator&& other) = default; 
  bool operator==(const SharedFieldIterator& other) { return (m_body == other.m_body && m_current_data_ptr == other.m_current_data_ptr); } 
  bool operator!=(const SharedFieldIterator& other) { return !(*this == other); }                                                       
  bool operator<(const SharedFieldIterator& other) { return m_body == other.m_body && m_current_data_ptr < other.m_current_data_ptr;}   
  bool operator>(const SharedFieldIterator& other) { return m_body == other.m_body && m_current_data_ptr > other.m_current_data_ptr;}    
  bool operator<=(const SharedFieldIterator& other) { return m_body == other.m_body && m_current_data_ptr <= other.m_current_data_ptr;} 
  bool operator>=(const SharedFieldIterator& other) { return m_body == other.m_body && m_current_data_ptr >= other.m_current_data_ptr;} 

  VALUE_TYPE operator*() const noexcept {
    if(m_is_current_pointee_cached)
      return m_current_data_value;
    else
      return convert_from_byte_array(m_current_data_ptr, 0);
  }

  /*
 * @brief - operator* is const function, hence cannot set m_current_data_value and m_is_current_pointee_cached
 */
  VALUE_TYPE read_and_cache_current_pointee() noexcept {
    m_current_data_value = *(*this);
    m_is_current_pointee_cached = true;
    return m_current_data_value;
  }

  SharedFieldIterator& operator+=(const int n) {
    m_current_data_ptr += n * m_bytes_per_value;
    m_is_current_pointee_cached = false;
    m_current_data_ptr = utils::cache_and_advance_to_end_if_necessary(m_current_data_ptr, m_end_data_ptr, *this);
    return *this;
  }

  SharedFieldIterator& operator-=(const int n) {
    m_current_data_ptr -= n * m_bytes_per_value;
    m_is_current_pointee_cached = false;
    return *this;
  }

  SharedFieldIterator& operator++() noexcept {
    m_current_data_ptr += m_bytes_per_value;
    m_is_current_pointee_cached = false;
    m_current_data_ptr = utils::cache_and_advance_to_end_if_necessary(m_current_data_ptr, m_end_data_ptr, *this);
    return *this;
  }

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


  SharedFieldIterator& operator--() {
    m_current_data_ptr -= m_bytes_per_value;
    m_is_current_pointee_cached = false;
    return *this;
  }

  SharedFieldIterator operator--(int) noexcept {
    const auto tmp = SharedFieldIterator(*this);
    operator--();
    return tmp;
  }
  int32_t operator-(const SharedFieldIterator& first) const {
    return static_cast<int32_t>(m_current_data_ptr - first.m_current_data_ptr)/m_bytes_per_value;
  }

  VALUE_TYPE operator[](const uint32_t index) const {
    return (index == 0 ? *(*this) : convert_from_byte_array(m_current_data_ptr, index));
  }

 private:
  std::shared_ptr<bcf1_t> m_body;
  const uint8_t* m_current_data_ptr;
  const uint8_t* m_original_data_ptr;
  const uint8_t* m_end_data_ptr;
  uint8_t m_bytes_per_value;
  utils::VariantFieldType m_type;
  VALUE_TYPE m_current_data_value;
  bool m_is_current_pointee_cached;

  VALUE_TYPE convert_from_byte_array(const uint8_t* data_ptr, int index) const;
};

template<> inline
int32_t SharedFieldIterator<int32_t>::convert_from_byte_array(const uint8_t* data_ptr, int index) const {
  return utils::convert_data_to_integer(data_ptr, index, m_bytes_per_value, m_type);
}

template<> inline
float SharedFieldIterator<float>::convert_from_byte_array(const uint8_t* data_ptr, int index) const {
  return utils::convert_data_to_float(data_ptr, index, m_bytes_per_value, m_type);
}

template<> inline
std::string SharedFieldIterator<std::string>::convert_from_byte_array(const uint8_t* data_ptr, int index) const {
  return utils::convert_data_to_string(data_ptr, index, m_bytes_per_value, m_type);
}

};

#endif // gamgee__shared_field_iterator__guard