cigar.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 <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;
    }
 
    cigar & assign_string(small_string<11> const s) noexcept
    {
        uint32_t num{};
        auto [ptr, errc] = std::from_chars(s.data(), s.data() + 10, num);
 
        if ((errc != std::errc{}) || (!char_is_valid_for<operation>(*ptr)) || (*(ptr + 1) != 0))
        {
            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;
    }
 
    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 {}))
};
 
template <typename char_t>
inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, cigar const c)
{
    s << c.to_string();
    return s;
}
 
inline namespace literals
{
 
// ------------------------------------------------------------------
// literals
// ------------------------------------------------------------------
 
constexpr cigar::operation operator""_cigar_operation(char const c) noexcept
{
    return cigar::operation{}.assign_char(c);
}
 
} // namespace literals
 
} // namespace seqan3