shared_field.h

Go to the documentation of this file.

#ifndef gamgee__shared_field__guard
#define gamgee__shared_field__guard

#include "shared_field_iterator.h"

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

#include "htslib/vcf.h"

#include <memory>
#include <sstream>
#include <stdexcept>

namespace gamgee {

template<class TYPE>
class SharedField {
 public:

  SharedField() : m_body {nullptr}, m_info_ptr {nullptr}, m_bytes_per_value {0} {} 

  explicit SharedField(const std::shared_ptr<bcf1_t>& body, const bcf_info_t* const info_ptr) :
    m_body {body},
    m_info_ptr {info_ptr},
    m_bytes_per_value {utils::size_for_type(static_cast<utils::VariantFieldType>(info_ptr->type), info_ptr)}
  {}

  SharedField(const SharedField& other) = delete;            
  SharedField& operator=(const SharedField& other) = delete; 
  SharedField(SharedField&& other) = default;                
  SharedField& operator=(SharedField&& other) = default;     

  bool operator==(const SharedField& 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 SharedField& other) const {
    return !(*this == other);
  }


  TYPE operator[](const uint32_t index) const {
    if (empty())
      throw std::out_of_range("Tried to index a shared field that is missing with operator[]");
    utils::check_max_boundary(index, m_info_ptr->len);
    return convert_from_byte_array(index); 
  }

  SharedFieldIterator<TYPE> begin() const {
    if (empty()) return SharedFieldIterator<TYPE>();
    return SharedFieldIterator<TYPE>{m_body, m_info_ptr->vptr, m_info_ptr->vptr + size() * m_bytes_per_value, m_bytes_per_value, static_cast<utils::VariantFieldType>(m_info_ptr->type)};
  }

  SharedFieldIterator<TYPE> end() const {
    if (empty()) return SharedFieldIterator<TYPE>();
    return SharedFieldIterator<TYPE>{m_body, m_info_ptr->vptr + size() * m_bytes_per_value, m_bytes_per_value, static_cast<utils::VariantFieldType>(m_info_ptr->type)};
  }

  uint32_t size() const { return m_info_ptr->len; } 
  bool empty() const { return m_body == nullptr; }  
  bool missing() const { return empty(); }          
  TYPE front() const { return operator[](0); }                    
  TYPE back() const { return operator[](m_info_ptr->len - 1); }   

 private:
  std::shared_ptr<bcf1_t> m_body;
  const bcf_info_t* m_info_ptr;
  uint8_t m_bytes_per_value;

  TYPE convert_from_byte_array(int index) const;
};

template<> inline
uint32_t SharedField<std::string>::size() const { return empty() ? 0 : 1; } 

template<> inline
int32_t SharedField<int32_t>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_integer(m_info_ptr->vptr, index, m_bytes_per_value, static_cast<utils::VariantFieldType>(m_info_ptr->type));
}

template<> inline
float SharedField<float>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_float(m_info_ptr->vptr, index, m_bytes_per_value, static_cast<utils::VariantFieldType>(m_info_ptr->type));
}

template<> inline
std::string SharedField<std::string>::convert_from_byte_array(int index) const {
  return utils::convert_data_to_string(m_info_ptr->vptr, index, m_bytes_per_value, static_cast<utils::VariantFieldType>(m_info_ptr->type));
}

template<> inline
std::string SharedField<std::string>::operator[](const uint32_t index) const {
  if (empty())
    throw std::out_of_range("Tried to index a shared field that is missing with operator[]");
  auto is_string_type = utils::is_string_type(m_info_ptr->type);
  auto limit = m_info_ptr->len; //cannot use size here as size<string> is specialized to return 1
  auto prefix_msg = "";
  if(is_string_type)
  {
    limit = 1u;
    prefix_msg = "INFO 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); 
}

} // end of namespace gamgee

#endif // gamgee__shared_field__guard