header.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <deque>
#include <ranges>
#include <unordered_map>
#include <vector>
 
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/io/sam_file/detail/cigar.hpp>
#include <seqan3/utility/views/type_reduce.hpp>
 
namespace seqan3
{
 
struct sam_file_program_info_t
{
    std::string id;                
    std::string name;              
    std::string command_line_call; 
    std::string previous;          
    std::string description;       
    std::string version;           
};
 
template <std::ranges::forward_range ref_ids_type = std::deque<std::string>>
class sam_file_header
{
public:
    sam_file_header() = default;                                   
    sam_file_header(sam_file_header const &) = delete;             
    sam_file_header & operator=(sam_file_header const &) = delete; 
    sam_file_header(sam_file_header &&) = default;                 
    sam_file_header & operator=(sam_file_header &&) = default;     
    ~sam_file_header() = default;                                  
 
    sam_file_header(ref_ids_type & ref_ids) : ref_ids_ptr{&ref_ids, ref_ids_deleter_noop}
    {}
 
    sam_file_header(ref_ids_type && ref_ids) :
        ref_ids_ptr{new ref_ids_type{std::move(ref_ids)}, ref_ids_deleter_default}
    {}
 
    using program_info_t =
        sam_file_program_info_t; 
    std::string format_version;  
    std::string sorting;         
    std::string
        subsorting; 
    std::string grouping; 
 
    std::vector<program_info_t> program_infos; 
 
    std::vector<std::string> comments; 
 
private:
    using ref_ids_ptr_t = std::unique_ptr<ref_ids_type, std::function<void(ref_ids_type *)>>;
    static void ref_ids_deleter_noop(ref_ids_type *)
    {}
    static void ref_ids_deleter_default(ref_ids_type * ptr)
    {
        delete ptr;
    }
    using key_type = std::conditional_t<std::ranges::contiguous_range<std::ranges::range_reference_t<ref_ids_type>>,
                                        std::span<range_innermost_value_t<ref_ids_type> const>,
                                        type_reduce_t<std::ranges::range_reference_t<ref_ids_type>>>;
    ref_ids_ptr_t ref_ids_ptr{new ref_ids_type{}, ref_ids_deleter_default};
 
    struct key_hasher
    {
        template <typename key_t>
        size_t operator()(key_t && key) const noexcept
        {
            using char_t = std::ranges::range_value_t<key_t>;
            size_t result{0};
            std::hash<char_t> h{};
            for (char_t character : key)
            {
                result *= 0x8F3F73B5CF1C9ADE;
                result += h(character);
            }
            return result;
        }
    };
 
public:
    ref_ids_type & ref_ids()
    {
        return *ref_ids_ptr;
    }
 
    std::vector<std::tuple<int32_t, std::string>> ref_id_info{};
 
    std::unordered_map<key_type, int32_t, key_hasher, detail::view_equality_fn> ref_dict{};
 
    std::vector<std::pair<std::string, std::string>> read_groups;
};
 
} // namespace seqan3