individual_field_value.h

Go to the documentation of this file.

#ifndef gamgee__individual_field_value__guard
#define gamgee__individual_field_value__guard

#include "individual_field_value_iterator.h"

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

#include "htslib/vcf.h"

#include <memory>

namespace gamgee {

template<class VALUE_TYPE>
class IndividualFieldValue {
 public:

  IndividualFieldValue(const std::shared_ptr<bcf1_t>& body, const bcf_fmt_t* const format_ptr, uint8_t* const data_ptr) :
    m_body {body},
    m_format_ptr {format_ptr},
    m_data_ptr {data_ptr},
    m_num_bytes {utils::size_for_type(static_cast<utils::VariantFieldType>(format_ptr->type), format_ptr)}
  {}

  IndividualFieldValue(const IndividualFieldValue& other) = delete;
  
  IndividualFieldValue(IndividualFieldValue&& other) :
    m_body {std::move(other.m_body)},
    m_format_ptr {other.m_format_ptr},
    m_data_ptr {other.m_data_ptr},
    m_num_bytes {other.m_num_bytes}
  {}

  IndividualFieldValue& operator=(const IndividualFieldValue& other) = delete;

  IndividualFieldValue& operator=(IndividualFieldValue&& other) {
    if (this != &other)
      return *this;
    m_body = std::move(other.m_body);
    m_format_ptr = other.m_format_ptr;
    m_data_ptr = other.m_data_ptr;
    m_num_bytes = other.m_num_bytes;
    return *this;
  }

  bool operator==(const IndividualFieldValue& other) const {
    if (this == &other) 
      return true;
    //Use iterators where possible as they take care of field sizes, bcf_*_vector_end
    auto other_iter = other.begin();
    auto other_end = other.end();
    for(const auto& curr_val : *this)
    {
      if(other_iter == other_end) //different length, this is longer (more valid values) than other
  return false;
      if(!utils::bcf_check_equal_element(curr_val, *other_iter))
  return false;
      ++other_iter;
    }
    //Check if other still has more valid values
    if(other_iter != other_end)
      return false;
    return true;
  }

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

  VALUE_TYPE operator[](const uint32_t index) const {
    utils::check_max_boundary(index, m_format_ptr->n);
    return convert_from_byte_array(index); 
  }

  IndividualFieldValueIterator<VALUE_TYPE> begin() const {
    return IndividualFieldValueIterator<VALUE_TYPE>{m_body, m_data_ptr, m_data_ptr + m_format_ptr->size, m_num_bytes, static_cast<utils::VariantFieldType>(m_format_ptr->type)};
  }

  IndividualFieldValueIterator<VALUE_TYPE> end() const {
    return IndividualFieldValueIterator<VALUE_TYPE>{m_body, m_data_ptr + m_format_ptr->size, m_data_ptr + m_format_ptr->size, m_num_bytes, static_cast<utils::VariantFieldType>(m_format_ptr->type)};
  }

  uint32_t size() const { return m_format_ptr->n; } 
  VALUE_TYPE front() const { return operator[](0); }                    
  VALUE_TYPE back() const { return operator[](m_format_ptr->n - 1); }   

  bool missing() const {
    // Important: relies on IndividualFieldValueIterator to skip vector end values, if there are any
    for (const auto& value : *this) {
      // use qualifier to avoid recursion
      if (!gamgee::missing(value))
        return false;
    }
    return true;
  }

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

  VALUE_TYPE convert_from_byte_array(int index) const;
};

template<> inline
int32_t IndividualFieldValue<int32_t>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_integer(m_data_ptr, index, m_num_bytes, static_cast<utils::VariantFieldType>(m_format_ptr->type));
}

template<> inline
float IndividualFieldValue<float>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_float(m_data_ptr, index, m_num_bytes, static_cast<utils::VariantFieldType>(m_format_ptr->type));
}

template<> inline
std::string IndividualFieldValue<std::string>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_string(m_data_ptr, index, m_num_bytes, static_cast<utils::VariantFieldType>(m_format_ptr->type));
}

template<> inline
std::string IndividualFieldValue<std::string>::operator[](const uint32_t index) const {
  auto is_string_type = utils::is_string_type(m_format_ptr->type);
  auto limit = size();
  auto prefix_msg = "";
  if(is_string_type)
  {
    limit = 1u;
    prefix_msg = "FORMAT fields of type string in VCFs have only 1 element per sample :: ";
  }
  utils::check_max_boundary(index, limit, prefix_msg);
  return convert_from_byte_array(index); 
}

}

#endif // gamgee__individual_field_value__guard