magic_header.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <array>
#include <seqan3/std/span>
#include <string>
#include <seqan3/std/type_traits>
#include <vector>
 
#include <seqan3/core/detail/template_inspection.hpp>
#include <seqan3/utility/detail/exposition_only_concept.hpp>
#include <seqan3/utility/detail/to_little_endian.hpp>
#include <seqan3/utility/type_pack/traits.hpp>
 
namespace seqan3::detail
{
 
struct gz_compression
{
    static inline std::vector<std::string> file_extensions
    {
        {"gz"}
    };
 
    static constexpr std::array<char, 3> magic_header{'\x1f', '\x8b', '\x08'};
};
 
struct bz2_compression
{
    static inline std::vector<std::string> file_extensions
    {
        {"bz2"}
    };
 
    static constexpr std::array<char, 3> magic_header{'\x42', '\x5a', '\x68'};
};
 
struct zstd_compression
{
    static inline std::vector<std::string> file_extensions
    {
        {"zst"}
    };
 
    static constexpr std::array<char, 4> magic_header{'\x28', '\xb5', '\x2f', '\xfd'};
};
 
struct bgzf_compression
{
    static inline std::vector<std::string> file_extensions
    {
        {"bgzf"}
    };
 
    static constexpr std::array<char, 18> magic_header
    {
    //  ID1                              ID2                              CM
        gz_compression::magic_header[0], gz_compression::magic_header[1], gz_compression::magic_header[2],
    //  FLG     [MTIME                       ]  XFL     OS      [XLEN        ]
        '\x04', '\x00', '\x00', '\x00', '\x00', '\x00', '\xff', '\x06', '\x00',
    //  B       C       [SLEN        ]  [BSIZE       ]
        '\x42', '\x43', '\x02', '\x00', '\x00', '\x00'
    };
 
    template <typename char_t, size_t extend>
    static bool validate_header(std::span<char_t, extend> header)
    {
        static_assert(seqan3::detail::weakly_equality_comparable_with<char_t, char>,
                      "The given char type of the span must be comparable with char.");
 
        return (header[0] == magic_header[0] &&                                                            // GZ_ID1
                header[1] == magic_header[1] &&                                                            // GZ_ID2
                header[2] == magic_header[2] &&                                                            // GZ_CM
                (header[3] & magic_header[3]) != 0 &&                                                      // FLG_FEXTRA
                to_little_endian(*reinterpret_cast<uint16_t const *>(&header[10])) == magic_header[10] &&  // BGZF_ID1
                header[12] == magic_header[12] &&                                                          // BGZF_ID2
                header[13] == magic_header[13] &&                                                          // BGZF_SLEN
                to_little_endian(*reinterpret_cast<uint16_t const *>(&header[14])) == magic_header[14]);   // BGZF_XLEN
    }
};
 
using compression_formats = pack_traits::drop_front<void
                                                    #if defined(SEQAN3_HAS_ZLIB)
                                                    , gz_compression
                                                    , bgzf_compression
                                                    #endif // defined(SEQAN3_HAS_ZLIB)
                                                    #if defined(SEQAN3_HAS_BZIP2)
                                                    , bz2_compression
                                                    #endif // defined(SEQAN3_HAS_BZIP2)
                                                    #if SEQAN3_HAS_ZSTD
                                                    , zstd_compression
                                                    #endif // SEQAN3_HAS_ZSTD
                                                    >;
 
} // namespace seqan3::detail