utils.h

Go to the documentation of this file.

#ifndef gamgee__utils__guard
#define gamgee__utils__guard

#include <string>
#include <memory>
#include <vector>
#include <sstream>
#include "htslib/vcf.h" 

namespace gamgee {

namespace utils {

std::string reverse_complement(const std::string& sequence);

std::string complement(const std::string& sequence); 

std::string complement(std::string& sequence);               

char complement (const char base);

std::vector<std::string> hts_string_array_to_vector(const char * const * const string_array, const uint32_t array_size);

inline void check_max_boundary(const uint32_t index, const uint32_t size, const std::string& prefix_msg) {
  if (index >= size) {
    std::stringstream error_message {};  
    error_message << prefix_msg << "Index:  " << index << " must be less than " << size << std::endl;
    throw std::out_of_range(error_message.str());
  }
}

inline void check_max_boundary(const uint32_t index, const uint32_t size) {
  check_max_boundary(index, size, "");
}
template<class TYPE>
inline bool bcf_check_equal_element(const TYPE& x, const TYPE& y) {
  return (x == y);
}
template<>
inline bool bcf_check_equal_element<float>(const float& x, const float& y) {
  return ((x == y) || (bcf_float_is_missing(x) && bcf_float_is_missing(y))
  || (bcf_float_is_vector_end(x) && bcf_float_is_vector_end(y)));
}

/*
 * @brief: returns true if value is the vector end for current TYPE
 * @note: for non numeric types returns false, as vector end is undefined
 */
template<class TYPE> inline
bool bcf_is_vector_end_value(const TYPE& value) {
  return false;
}

/*
 * @brief specialization of the bcf_is_vector_end_value function for int32_t
 */
template<> inline
bool bcf_is_vector_end_value<int32_t>(const int32_t& value) {
  return (value == bcf_int32_vector_end);
}

/*
 * @brief specialization of the bcf_is_vector_end_value function for float
 */
template<> inline
bool bcf_is_vector_end_value<float>(const float& value) {
  return bcf_float_is_vector_end(value);
}



template<class ITER> inline
const uint8_t* cache_and_advance_to_end_if_necessary(const uint8_t* current_ptr, const uint8_t* end_ptr, ITER& it) {
  if(end_ptr != nullptr && current_ptr < end_ptr 
      && utils::bcf_is_vector_end_value(it.read_and_cache_current_pointee()))
    return end_ptr;
  return current_ptr;
}


} // end utils namespace
} // end gamgee namespace

#endif // gamgee__utils__guard