alphabet/cigar/cigar.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 <seqan3/std/charconv>
 
#include <seqan3/alphabet/adaptation/uint.hpp>
#include <seqan3/alphabet/cigar/exposition_only/cigar_operation.hpp>
#include <seqan3/alphabet/composite/alphabet_tuple_base.hpp>
#include <seqan3/core/debug_stream/debug_stream_type.hpp>
#include <seqan3/utility/container/small_string.hpp>
 
// ------------------------------------------------------------------
// cigar
// ------------------------------------------------------------------
 
namespace seqan3
{
 
class cigar : public alphabet_tuple_base<cigar, uint32_t, exposition_only::cigar_operation>
{
private:
    using base_t = alphabet_tuple_base<cigar, uint32_t, exposition_only::cigar_operation>;
 
    friend base_t;
 
public:
    using operation = exposition_only::cigar_operation;
 
    constexpr cigar() noexcept = default;                          
    constexpr cigar(cigar const &) noexcept = default;             
    constexpr cigar(cigar &&) noexcept = default;                  
    constexpr cigar & operator=(cigar const &) noexcept = default; 
    constexpr cigar & operator=(cigar &&) noexcept = default;      
    ~cigar() noexcept = default;                                   
 
    // Inherit constructors from base
    using base_t::base_t;
 
    SEQAN3_DOXYGEN_ONLY((constexpr cigar(component_type const alph) noexcept {}))
 
    SEQAN3_DOXYGEN_ONLY((constexpr cigar & operator=(component_type const alph) noexcept {}))
 
    // Inherit operators from base
    using base_t::operator=;
 
    small_string<11> to_string() const noexcept
    {
        small_string<11> ret{}; // maximum number of digits for uint32_t + 1 char for the cigar operation
        ret.resize(11);
 
        auto [ptr, errc] = std::to_chars(ret.data(), ret.data() + 10, get<0>(*this));
 
        *ptr = seqan3::to_char(get<1>(*this));
        (void)errc;
 
        ret.resize(ptr - ret.data() + 1);
        return ret;
    }
    small_string<11> to_string() const noexcept {…}
 
    cigar & assign_string(std::string_view const input) noexcept
    {
        uint32_t num{};
        auto [ptr, errc] = std::from_chars(input.data(), input.data() + input.size(), num);
 
        if ((errc != std::errc{}) || (!char_is_valid_for<operation>(*ptr)))
        {
            get<0>(*this) = 0;
            assign_char_to('P', get<1>(*this));
        }
        else
        {
            get<0>(*this) = num;
            assign_char_to(*ptr, get<1>(*this));
        }
 
        return *this;
    }
    cigar & assign_string(std::string_view const input) noexcept {…}
 
    SEQAN3_DOXYGEN_ONLY((friend template <size_t index> constexpr auto get(cigar & l) noexcept {}))
 
    
    SEQAN3_DOXYGEN_ONLY((friend template <typename type> constexpr auto get(cigar & l) noexcept {}))
};
class cigar : public alphabet_tuple_base<cigar, uint32_t, exposition_only::cigar_operation> {…};
 
template <>
struct cigar_printer<cigar>
{
    template <typename stream_t>
    constexpr void operator()(stream_t & stream, cigar const arg) const noexcept
    {
        stream << arg.to_string();
    }
    constexpr void operator()(stream_t & stream, cigar const arg) const noexcept {…}
};
struct cigar_printer<cigar> {…};
 
inline namespace literals
{
 
// ------------------------------------------------------------------
// literals
// ------------------------------------------------------------------
 
constexpr cigar::operation operator""_cigar_operation(char const c) noexcept
{
    return cigar::operation{}.assign_char(c);
}
constexpr cigar::operation operator""_cigar_operation(char const c) noexcept {…}
 
} // namespace literals
 
} // namespace seqan3