char_to.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <concepts>
#include <ranges>
#include <type_traits>
 
#include <bio/alphabet/cigar/cigar.hpp>
#include <bio/alphabet/custom/all.hpp>
#include <bio/meta/overloaded.hpp>
#include <bio/ranges/container/small_string.hpp>
#include <bio/ranges/type_traits.hpp>
#include <bio/ranges/views/deep.hpp>
#include <bio/ranges/views/type_reduce.hpp>
 
#include "bio/alphabet/detail/to_lower.hpp"
#include "bio/alphabet/exception.hpp"
#include "bio/ranges/concept.hpp"
 
namespace bio::ranges::detail
{
 
// ---------------------------------------------------------------------------------------------------------------------
// char_to_cigar_view class
// ---------------------------------------------------------------------------------------------------------------------
 
template <std::ranges::view urng_t>
    requires std::ranges::forward_range<urng_t>
class char_to_cigar_view : public std::ranges::view_interface<char_to_cigar_view<urng_t>>
{
private:
    urng_t urange;
 
    template <typename uit_t, typename usen_t>
    class iterator;
 
    using it_t = iterator<std::ranges::iterator_t<urng_t>, std::ranges::sentinel_t<urng_t>>;
    using const_it_t =
      std::conditional_t<const_iterable_range<urng_t>,
                         iterator<std::ranges::iterator_t<urng_t const>, std::ranges::sentinel_t<urng_t const>>,
                         void>;
 
public:
    char_to_cigar_view()                                           = default; 
    char_to_cigar_view(char_to_cigar_view const &)                 = default; 
    char_to_cigar_view & operator=(char_to_cigar_view const &)     = default; 
    char_to_cigar_view(char_to_cigar_view &&) noexcept             = default; 
    char_to_cigar_view & operator=(char_to_cigar_view &&) noexcept = default; 
    ~char_to_cigar_view()                                          = default; 
 
    constexpr explicit char_to_cigar_view(urng_t _urange) : urange{std::move(_urange)} {}
 
    constexpr auto begin() noexcept
    {
        return ++it_t{std::ranges::begin(urange), std::ranges::begin(urange), std::ranges::end(urange)};
    }
 
    constexpr auto begin() const noexcept
        requires const_iterable_range<urng_t>
    {
        return ++const_it_t{std::ranges::begin(urange), std::ranges::begin(urange), std::ranges::end(urange)};
    }
 
    constexpr auto end() noexcept
    {
        if constexpr (std::ranges::common_range<urng_t>)
            return it_t{std::ranges::end(urange), std::ranges::begin(urange), std::ranges::end(urange)};
        else
            return std::ranges::end(urange);
    }
 
    constexpr auto end() const noexcept
        requires const_iterable_range<urng_t>
    {
        if constexpr (std::ranges::common_range<urng_t>)
            return const_it_t{std::ranges::end(urange), std::ranges::begin(urange), std::ranges::end(urange)};
        else
            return std::ranges::end(urange);
    }
};
 
// ---------------------------------------------------------------------------------------------------------------------
// char_to_cigar_view::iterator class
// ---------------------------------------------------------------------------------------------------------------------
 
template <std::ranges::view urng_t>
    requires std::ranges::forward_range<urng_t>
template <typename uit_t, typename usen_t>
class char_to_cigar_view<urng_t>::iterator
{
private:
    static constexpr alphabet::cigar default_value{(2u << 28) - 1, alphabet::assign_char_to('B', alphabet::cigar_op{})};
 
    static constexpr bool is_digit(char const c) { return c >= '0' && c <= '9'; }
 
    static constexpr bool is_alpha(char const c)
    {
        return alphabet::detail::is_lower(c) || alphabet::detail::is_upper(c);
    }
 
    uit_t           uit_left;
    uit_t           uit_right;
    uit_t           ubeg;
    usen_t          usen;
    alphabet::cigar value = default_value;
 
    static constexpr bool nothrow_default_init =
      std::is_nothrow_default_constructible_v<uit_t> && std::is_nothrow_default_constructible_v<usen_t>;
    static constexpr bool nothrow_move_init =
      std::is_nothrow_move_constructible_v<uit_t> && std::is_nothrow_move_constructible_v<usen_t>;
    static constexpr bool nothrow_copy_init =
      std::is_nothrow_copy_constructible_v<uit_t> && std::is_nothrow_copy_constructible_v<usen_t>;
    static constexpr bool nothrow_move_assign =
      std::is_nothrow_move_assignable_v<uit_t> && std::is_nothrow_move_assignable_v<usen_t>;
    static constexpr bool nothrow_copy_assign =
      std::is_nothrow_copy_assignable_v<uit_t> && std::is_nothrow_copy_assignable_v<usen_t>;
 
public:
    using difference_type   = std::iter_difference_t<uit_t>;
    using value_type        = alphabet::cigar;
    using reference         = alphabet::cigar;
    using pointer           = void *;
    using iterator_category = std::input_iterator_tag;
    using iterator_concept  = std::conditional_t<std::random_access_iterator<uit_t>,
                                                std::bidirectional_iterator_tag,
                                                detail::iterator_concept_tag_t<uit_t>>;
 
    constexpr iterator() noexcept(nothrow_default_init)                                = default; 
    constexpr iterator(iterator const & rhs) noexcept(nothrow_copy_init)               = default; 
    constexpr iterator(iterator && rhs) noexcept(nothrow_move_init)                    = default; 
    constexpr iterator & operator=(iterator const & rhs) noexcept(nothrow_copy_assign) = default; 
    constexpr iterator & operator=(iterator && rhs) noexcept(nothrow_move_assign)      = default; 
    ~iterator() noexcept(std::is_nothrow_destructible_v<uit_t>)                        = default; 
 
    constexpr iterator(uit_t const it, uit_t const beg, usen_t const sen) noexcept(nothrow_copy_init) :
      uit_left{it}, uit_right{it}, ubeg{beg}, usen{sen}
    {}
 
    constexpr friend bool operator==(iterator const & lhs, iterator const & rhs) noexcept(
      noexcept(std::declval<uit_t &>() == std::declval<uit_t &>()))
    {
        return lhs.uit_left == rhs.uit_left;
    }
 
    constexpr friend bool operator==(iterator const & lhs, usen_t const & rhs) noexcept(
      noexcept(std::declval<uit_t &>() == std::declval<usen_t &>()))
        requires(!std::same_as<uit_t, usen_t>)
    {
        return lhs.uit_left == rhs;
    }
 
    constexpr friend auto operator<=>(iterator const & lhs, iterator const & rhs) noexcept(
      noexcept(std::declval<uit_t &>() < std::declval<uit_t &>()))
        requires std::totally_ordered<uit_t>
    {
        return lhs.uit_left <=> rhs.uit_left;
    }
 
    constexpr iterator & operator++()
    {
        value = default_value;
 
        if (uit_left != uit_right) // every increment except the first
            uit_left = uit_right;
 
        if (uit_left == usen) // at end
            return *this;
 
        while (!is_alpha(*uit_right))
        {
            assert(is_digit(*uit_right));
            ++uit_right;
            assert(uit_right != usen);
        }
 
        ++uit_right; // go behind alpha
 
        return *this;
    }
 
    constexpr auto operator++(int)
    {
        auto copy = *this;
        ++(*this);
        return copy;
    }
 
    constexpr iterator & operator--()
        requires(requires(uit_t i) { --i; })
    {
        assert(uit_left != ubeg);
 
        value = default_value;
 
        uit_right = uit_left;
 
        --uit_left;
        assert(is_alpha(*uit_left));
 
        do
        {
            --uit_left;
        }
        while (is_digit(*uit_left) && uit_left != ubeg);
 
        if (uit_left != ubeg)
            ++uit_left;
 
        return *this;
    }
 
    constexpr auto operator--(int)
        requires(requires(uit_t i) { --i; })
    {
        auto copy = *this;
        --(*this);
        return copy;
    }
 
    constexpr value_type operator*()
    {
        if (value == default_value)
        {
            if constexpr (std::contiguous_iterator<uit_t>)
            {
                std::string_view v{uit_left, uit_right};
                value.assign_string(v);
            }
            else
            {
                std::string s;
                std::ranges::copy(uit_left, uit_right, std::back_inserter(s));
                value.assign_string(s);
            }
        }
        return value;
    }
 
    constexpr value_type operator*() const
    {
        alphabet::cigar c;
 
        if constexpr (std::contiguous_iterator<uit_t>)
        {
            std::string_view v{uit_left, uit_right};
            c.assign_string(v);
        }
        else
        {
            std::string s;
            std::ranges::copy(uit_left, uit_right, std::back_inserter(s));
            c.assign_string(s);
        }
        return c;
    }
 
    constexpr pointer operator->() noexcept(noexcept(*std::declval<uit_t &>()))
        requires std::input_iterator<uit_t>
    {
        return this;
    }
 
    constexpr decltype(auto) operator->() const noexcept(noexcept(*std::declval<uit_t const &>()))
        requires std::input_iterator<uit_t>
    {
        return this;
    }
};
 
} // namespace bio::ranges::detail
 
// ---------------------------------------------------------------------------------------------------------------------
// enable_borrowed_range
// ---------------------------------------------------------------------------------------------------------------------
 
// Mark char_to_cigar_view as conditionally borrowed.
template <typename urng_t>
inline constexpr bool std::ranges::enable_borrowed_range<bio::ranges::detail::char_to_cigar_view<urng_t>> =
  std::ranges::borrowed_range<urng_t>;
 
// ---------------------------------------------------------------------------------------------------------------------
// views::char_to
// ---------------------------------------------------------------------------------------------------------------------
 
namespace bio::ranges::views
{
 
template <typename alphabet_type>
    requires(alphabet::alphabet<alphabet_type> || std::same_as<alphabet_type, alphabet::cigar>)
inline constexpr auto char_to = detail::adaptor_from_functor{meta::overloaded{
  // clang-format off
    // cigar special case below
    // char2char special case
    []<std::ranges::input_range rng_t>(rng_t && range)
        requires(std::convertible_to<ranges::range_innermost_value_t<rng_t>, alphabet::char_t<alphabet_type>> &&
                 std::same_as<ranges::range_innermost_value_t<rng_t>, alphabet_type>)
    {
        return std::forward<rng_t>(range) | views::type_reduce; // NOP
    },
    // generic case
    []<std::ranges::input_range rng_t>(rng_t && range)
        requires(std::convertible_to<ranges::range_innermost_value_t<rng_t>, alphabet::char_t<alphabet_type>>)
    {
        auto fn = [] (alphabet::char_t<alphabet_type> const in) -> alphabet_type
        {
            return alphabet::assign_char_to(in, alphabet_type{});
        };
        return std::forward<rng_t>(range) | deep{std::views::transform(fn)};
    },
    // catch-all
    []<typename rng_t>(rng_t &&)
    {
        static_assert(meta::always_false<rng_t>,
                      "The type you pass to bio::views::char_to must be a range of elements convertible "
                      "to the target alphabet's character type.");
    }}};
// clang-format on
 
template <>
inline constexpr auto char_to<alphabet::cigar> = detail::adaptor_from_functor{
  // clang-format off
    []<typename rng_t>(rng_t && range)
    {
        static_assert(std::ranges::forward_range<rng_t> && std::same_as<std::ranges::range_value_t<rng_t>, char>,
                      "The type you pass to bio::views::char_to<bio::alphabet::cigar> must be a forward_range "
                      "over char.");
        return detail::char_to_cigar_view{views::type_reduce(std::forward<rng_t>(range))};
    }};
// clang-format on
 
 
} // namespace bio::ranges::views