header.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 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;           
    std::string user_tags;         
};

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 &) = default;             
    sam_file_header & operator=(sam_file_header const &) = default; 
    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) : reference_ids{std::move(ref_ids)}
    {}

 
    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 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_type reference_ids{};

    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 *= 0x8F'3F'73'B5'CF'1C'9A'DE;
                result += h(character);
            }
            return result;
        }
    };
 
public:
    ref_ids_type & ref_ids()
    {
        return reference_ids;
    }

    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;
 
    std::string user_tags; 
};
 
} // namespace seqan3