individual_field_value_iterator.h

Go to the documentation of this file.

#ifndef gamgee__individual_field_value_iterator__guard
#define gamgee__individual_field_value_iterator__guard

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

#include "htslib/vcf.h"

#include <iterator>
#include <memory>

namespace gamgee {

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

  explicit IndividualFieldValueIterator(const std::shared_ptr<bcf1_t>& body, uint8_t* data_ptr, uint8_t* end_ptr, const uint8_t num_bytes, 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_num_bytes {num_bytes},
    m_type {type},
    m_is_current_pointee_cached {false}
  {}

  explicit IndividualFieldValueIterator(const std::shared_ptr<bcf1_t>& body, uint8_t* data_ptr, const uint8_t num_bytes, const utils::VariantFieldType& type): IndividualFieldValueIterator(body, data_ptr, nullptr, num_bytes, type)
  {}
  
  IndividualFieldValueIterator(const IndividualFieldValueIterator& other) :
    m_body {other.m_body},
    m_current_data_ptr {other.m_current_data_ptr},
    m_original_data_ptr {other.m_original_data_ptr},
    m_end_data_ptr {other.m_end_data_ptr},
    m_num_bytes {other.m_num_bytes},
    m_type {other.m_type},
    m_current_data_value {other.m_current_data_value},
    m_is_current_pointee_cached {other.m_is_current_pointee_cached}
  {}

  IndividualFieldValueIterator(IndividualFieldValueIterator&& other) noexcept :
    m_body {std::move(other.m_body)},
    m_current_data_ptr {other.m_current_data_ptr},
    m_original_data_ptr {other.m_original_data_ptr},
    m_end_data_ptr {other.m_end_data_ptr},
    m_num_bytes {other.m_num_bytes},
    m_type {other.m_type},
    m_current_data_value {other.m_current_data_value},
    m_is_current_pointee_cached {other.m_is_current_pointee_cached}
  {}

  IndividualFieldValueIterator& operator=(const IndividualFieldValueIterator& other) {
    if (&this == other)
      return *this;
    m_body = std::move(other.m_body);
    m_current_data_ptr = other.m_current_data_ptr;
    m_original_data_ptr = other.m_original_data_ptr;
    m_end_data_ptr  = other.m_end_data_ptr;
    m_num_bytes = other.m_num_bytes;
    m_type = other.m_type;
    m_current_data_value = other.m_current_data_value;
    m_is_current_pointee_cached = other.m_is_current_pointee_cached;
    return *this;
  }


  IndividualFieldValueIterator& operator=(IndividualFieldValueIterator&& other) noexcept {
    if (&this == other)
      return *this;
    m_body = std::move(other.m_body);
    m_current_data_ptr = other.m_current_data_ptr;
    m_original_data_ptr = other.m_original_data_ptr;
    m_end_data_ptr  = other.m_end_data_ptr;
    m_num_bytes = other.m_num_bytes;
    m_type = other.m_type;
    m_current_data_value = other.m_current_data_value;
    m_is_current_pointee_cached = other.m_is_current_pointee_cached;
    return *this;
  }

  IndividualFieldValueIterator& operator+=(const int n) {
    m_current_data_ptr += n * m_num_bytes;
    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;
  }

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

  bool operator==(const IndividualFieldValueIterator& other) { return (m_body == other.m_body && m_current_data_ptr == other.m_current_data_ptr); }

  bool operator!=(const IndividualFieldValueIterator& other) {
    return !(*this == other);
  }

  bool operator<(const IndividualFieldValueIterator& other) {
    return m_body == other.m_body && m_current_data_ptr < other.m_current_data_ptr;
  }

  bool operator>(const IndividualFieldValueIterator& other) {
    return m_body == other.m_body && m_current_data_ptr > other.m_current_data_ptr;
  }

  bool operator<=(const IndividualFieldValueIterator& other) {
    return m_body == other.m_body && m_current_data_ptr <= other.m_current_data_ptr;
  }

  bool operator>=(const IndividualFieldValueIterator& 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;
  }
  IndividualFieldValueIterator& operator++() noexcept {
    m_current_data_ptr += m_num_bytes;
    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;
  }

  IndividualFieldValueIterator operator++(int) noexcept {
    auto const tmp = IndividualFieldValueIterator(*this);
    operator++();
    return tmp;
  }
  IndividualFieldValueIterator& operator--() {
    m_current_data_ptr -= m_num_bytes;
    m_is_current_pointee_cached = false;
    return *this;
  }

  IndividualFieldValueIterator operator--(int) noexcept {
    auto const tmp = IndividualFieldValueIterator(*this);
    operator--();
    return tmp;
  }
  VALUE_TYPE operator[](const uint32_t index) const {
    //if index == 0, use the cached value logic in operator*
    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_num_bytes;
  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 IndividualFieldValueIterator<int32_t>::convert_from_byte_array(const uint8_t* data_ptr, int index) const {
  return utils::convert_data_to_integer(data_ptr, index, m_num_bytes, m_type);
}

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

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

};

#endif // gamgee__individual_field_value_iterator__guard