masked.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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/alphabet/mask/all.hpp>
#include <seqan3/alphabet/composite/alphabet_tuple_base.hpp>
#include <seqan3/core/char_operations/predicate.hpp>
#include <seqan3/core/char_operations/transform.hpp>

namespace seqan3
{
 template <typename sequence_alphabet_t>
    requires WritableAlphabet<sequence_alphabet_t>
class masked : public alphabet_tuple_base<masked<sequence_alphabet_t>, sequence_alphabet_t, mask>
{
private:
    using base_type = alphabet_tuple_base<masked<sequence_alphabet_t>, sequence_alphabet_t, mask>;

public:
    using sequence_alphabet_type = sequence_alphabet_t;

    using char_type = alphabet_char_t<sequence_alphabet_type>;

    using base_type::alphabet_size;

    constexpr masked() : base_type{} {}                      
    constexpr masked(masked const &) = default;              
    constexpr masked(masked &&) = default;                   
    constexpr masked & operator =(masked const &) = default; 
    constexpr masked & operator =(masked &&) = default;      
    ~masked() = default;                                     

    using base_type::base_type; // Inherit non-default constructors

    SEQAN3_DOXYGEN_ONLY(( constexpr masked(component_type const alph) {} ))
    SEQAN3_DOXYGEN_ONLY(( constexpr masked(indirect_component_type const alph) {} ))
    SEQAN3_DOXYGEN_ONLY(( constexpr masked & operator=(component_type const alph) {} ))
    SEQAN3_DOXYGEN_ONLY(( constexpr masked & operator=(indirect_component_type const alph) {} ))

    // Inherit operators from base
    using base_type::operator=;
    using base_type::operator==;
    using base_type::operator!=;
    using base_type::operator>=;
    using base_type::operator<=;
    using base_type::operator<;
    using base_type::operator>;

    constexpr masked & assign_char(char_type const c) noexcept
    {
        seqan3::assign_char_to(c, get<0>(*this));
        seqan3::assign_rank_to(is_lower(c), get<1>(*this));
        return *this;
    }

    masked & assign_char_strictly(char_type const c)
    {
        if (!char_is_valid(c))
            throw invalid_char_assignment{detail::get_display_name_v<masked>, c};

        return assign_char(c);
    }

    constexpr char_type to_char() const noexcept
    {
        if (seqan3::to_rank(get<1>(*this)))
        {
            return to_lower(seqan3::to_char(get<0>(*this)));
        }
        else
        {
            return seqan3::to_char(get<0>(*this));
        }
    }

    static constexpr bool char_is_valid(char_type const c) noexcept
    {
        return masked{}.assign_char(c).to_char() == c;
    }
};

template <typename sequence_alphabet_type>
masked(sequence_alphabet_type &&, mask const &)
    -> masked<std::decay_t<sequence_alphabet_type>>;
} //namespace seqan3