individual_field.h

Go to the documentation of this file.

#ifndef gamgee__individual_field__guard
#define gamgee__individual_field__guard

#include <iostream>

#include "individual_field_iterator.h"

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

#include "htslib/vcf.h"

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

namespace gamgee {

template<class TYPE>
class IndividualField {
 public:

  IndividualField() : m_body {nullptr}, m_format_ptr {nullptr} {} 

  explicit IndividualField(const std::shared_ptr<bcf1_t>& body, bcf_fmt_t* format_ptr) :
    m_body {body}, m_format_ptr {format_ptr} 
  {}

  IndividualField(const IndividualField& other) = delete;

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

  IndividualField& operator=(IndividualField&& other) = default;

  bool operator==(const IndividualField& other) const {
    if (this == &other) 
      return true;
    if (size() != other.size()) 
      return false;
    for (auto i=0u; i != size(); ++i) {
      if (operator[](i) != other[i])
        return false;
    }
    return true;
  }

  bool operator!=(const IndividualField& other) const {
    return !(*this == other);
  }
  
  TYPE operator[](const uint32_t sample) const {
    if (empty())
      throw std::out_of_range("Tried to index an individual field that is missing with operator[]");
    utils::check_max_boundary(sample, m_body->n_sample);
    return TYPE{m_body, m_format_ptr, m_format_ptr->p + (sample * m_format_ptr->size)}; 
  }

  IndividualFieldIterator<TYPE> begin() const {
    return IndividualFieldIterator<TYPE>{m_body, m_format_ptr};
  }

  IndividualFieldIterator<TYPE> end() const {
    return IndividualFieldIterator<TYPE>{m_body, m_format_ptr, true};
  }

  uint32_t size() const { return empty() ? 0 : m_body->n_sample; } 
  uint32_t n_samples() const { return size(); }                    
  uint32_t empty() const { return m_body == nullptr; }             
  uint32_t missing() const { return empty();}                      
  TYPE front() const { return operator[](0); }                     
  TYPE back() const { return operator[](m_body->n_sample - 1); }   

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


}

#endif // gamgee__individual_field__guard