aligned_sequence_concept.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, 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/algorithm>
#include <seqan3/std/ranges>
 
#include <seqan3/alignment/exception.hpp>
#include <seqan3/alphabet/gap/gapped.hpp>
#include <seqan3/range/concept.hpp>
#include <seqan3/range/container/concept.hpp>
 
// ---------------------------------------------------------------------------------------------------------------------
// unaligned_seq transformation trait
// ---------------------------------------------------------------------------------------------------------------------
 
namespace seqan3::detail
{
 
template <template <typename ...> typename container_type, typename seq_alph_t, typename ...rest_t>
    requires container<container_type<gapped<seq_alph_t>, rest_t...>>
constexpr auto remove_gap_from_value_type(container_type<gapped<seq_alph_t>, rest_t...>)
    -> container_type<seq_alph_t, rest_t...>;
 
template <template <typename ...> typename container_type,
          template <typename ...> typename allocator_type,
          typename seq_alph_t, typename ...rest_t>
    requires container<container_type<gapped<seq_alph_t>, allocator_type<gapped<seq_alph_t>>, rest_t...>>
constexpr auto remove_gap_from_value_type(container_type<gapped<seq_alph_t>, allocator_type<gapped<seq_alph_t>>, rest_t...>)
    -> container_type<seq_alph_t, allocator_type<seq_alph_t>, rest_t...>;
 
template <typename t>
struct unaligned_seq
{};
 
template <typename t>
    requires (!requires { typename std::remove_reference_t<t>::unaligned_seq_type; }) &&
              requires { remove_gap_from_value_type(std::declval<t>()); }
struct unaligned_seq<t>
{
    using type = decltype(remove_gap_from_value_type(std::declval<t>()));
};
 
// customisation point for our gap decorators.
template <typename t>
    requires requires { typename std::remove_reference_t<t>::unaligned_seq_type; }
struct unaligned_seq<t>
{
    using type = typename std::remove_reference_t<t>::unaligned_seq_type; 
};
 
template <typename t>
using unaligned_seq_t = typename unaligned_seq<t>::type;
 
} // namespace seqan3::detail
 
// ---------------------------------------------------------------------------------------------------------------------
// aligned_sequence
// ---------------------------------------------------------------------------------------------------------------------
 
namespace seqan3
{
 
template <typename t>
SEQAN3_CONCEPT aligned_sequence =
    sequence<t> &&
    std::equality_comparable_with<std::ranges::range_reference_t<t>, gap>;
 
template <typename t>
SEQAN3_CONCEPT writable_aligned_sequence =
    aligned_sequence<t> &&
    std::ranges::forward_range<t> &&
    requires { typename detail::unaligned_seq_t<t>; } &&
    requires (t v, detail::unaligned_seq_t<t> unaligned)
    {
        // global functions for generic usability
        SEQAN3_RETURN_TYPE_CONSTRAINT(insert_gap(v, std::ranges::begin(v)), std::same_as, std::ranges::iterator_t<t>);
        SEQAN3_RETURN_TYPE_CONSTRAINT(insert_gap(v, std::ranges::begin(v), 2),
                                      std::same_as, std::ranges::iterator_t<t>);
        SEQAN3_RETURN_TYPE_CONSTRAINT(erase_gap(v, std::ranges::begin(v)), std::same_as, std::ranges::iterator_t<t>);
        SEQAN3_RETURN_TYPE_CONSTRAINT(erase_gap(v, std::ranges::begin(v), std::ranges::end(v)),
                                      std::same_as, std::ranges::iterator_t<t>);
        SEQAN3_RETURN_TYPE_CONSTRAINT(assign_unaligned(v, unaligned), std::same_as, void);
    };
 
// ---------------------------------------------------------------------------------------------------------------------
// Aligned sequence interface for containers over the seqan3::gapped alphabet
// ---------------------------------------------------------------------------------------------------------------------
 
template <sequence_container aligned_seq_t>
    requires detail::is_gapped_alphabet<std::iter_value_t<aligned_seq_t>>
inline typename aligned_seq_t::iterator insert_gap(aligned_seq_t & aligned_seq,
                                                   typename aligned_seq_t::const_iterator pos_it)
{
    return aligned_seq.insert(pos_it, std::iter_value_t<aligned_seq_t>{gap{}});
}
 
template <sequence_container aligned_seq_t>
    requires detail::is_gapped_alphabet<std::iter_value_t<aligned_seq_t>>
inline typename aligned_seq_t::iterator insert_gap(aligned_seq_t & aligned_seq,
                                                   typename aligned_seq_t::const_iterator pos_it,
                                                   typename aligned_seq_t::size_type size)
{
    return aligned_seq.insert(pos_it, size, std::iter_value_t<aligned_seq_t>{gap{}});
}
 
template <sequence_container aligned_seq_t>
    requires detail::is_gapped_alphabet<std::iter_value_t<aligned_seq_t>>
inline typename aligned_seq_t::iterator erase_gap(aligned_seq_t & aligned_seq,
                                                  typename aligned_seq_t::const_iterator pos_it)
{
    if (*pos_it != gap{}) // [[unlikely]]
        throw gap_erase_failure("The position to be erased does not contain a gap.");
 
    return aligned_seq.erase(pos_it);
}
 
template <sequence_container aligned_seq_t>
    requires detail::is_gapped_alphabet<std::iter_value_t<aligned_seq_t>>
inline typename aligned_seq_t::iterator erase_gap(aligned_seq_t & aligned_seq,
                                                  typename aligned_seq_t::const_iterator first,
                                                  typename aligned_seq_t::const_iterator last)
{
    for (auto it = first; it != last; ++it)
        if (*it != gap{}) // [[unlikely]]
            throw gap_erase_failure("The range to be erased contains at least one non-gap character.");
 
    return aligned_seq.erase(first, last);
}
 
template <sequence_container aligned_seq_t, std::ranges::forward_range unaligned_sequence_type>
    requires detail::is_gapped_alphabet<std::iter_value_t<aligned_seq_t>> &&
             weakly_assignable_from<std::ranges::range_reference_t<aligned_seq_t>,
                                    std::ranges::range_reference_t<unaligned_sequence_type>>
inline void assign_unaligned(aligned_seq_t & aligned_seq, unaligned_sequence_type && unaligned_seq)
{
    using std::swap;
    aligned_seq_t tmp;
    tmp.resize(std::ranges::distance(unaligned_seq));
    std::ranges::copy(unaligned_seq, std::ranges::begin(tmp));
    swap(aligned_seq, tmp);
}
 
template <typename range_type>
    requires requires (range_type v)
        {
            v.insert_gap(std::ranges::iterator_t<range_type>{});
            v.insert_gap(std::ranges::iterator_t<range_type>{}, typename range_type::size_type{});
        }
std::ranges::iterator_t<range_type> insert_gap(range_type & rng,
                                               std::ranges::iterator_t<range_type> const pos_it,
                                               typename range_type::size_type const size = 1)
{
    return rng.insert_gap(pos_it, size);
}
 
template <typename range_type>
    requires requires (range_type v) { v.erase_gap(std::ranges::iterator_t<range_type>{}); }
std::ranges::iterator_t<range_type> erase_gap(range_type & rng,
                                              std::ranges::iterator_t<range_type> const pos_it)
{
    return rng.erase_gap(pos_it);
}
 
template <typename range_type>
    requires requires (range_type v) { v.erase_gap(std::ranges::iterator_t<range_type>{}, std::ranges::iterator_t<range_type>{}); }
std::ranges::iterator_t<range_type> erase_gap(range_type & rng,
                                              std::ranges::iterator_t<range_type> const first,
                                              std::ranges::iterator_t<range_type> const last)
{
    return rng.erase_gap(first, last);
}
} // namespace seqan3
 
namespace seqan3::detail
{
 
template <typename ...elems>
inline bool constexpr all_model_aligned_seq = (aligned_sequence<elems> && ...);
 
template <typename ...elems>
inline bool constexpr all_model_aligned_seq<type_list<elems...>> = all_model_aligned_seq<elems...>;
 
template <typename ...elems>
inline bool constexpr all_model_writable_aligned_seq = (writable_aligned_sequence<elems> && ...);
 
template <typename ...elems>
inline bool constexpr all_model_writable_aligned_seq<type_list<elems...>> = all_model_writable_aligned_seq<elems...>;
} // namespace seqan3::detail