slice.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 <stdexcept>
 
#include <seqan3/io/exception.hpp>
#include <seqan3/range/concept.hpp>
#include <seqan3/range/views/detail.hpp>
#include <seqan3/range/views/drop.hpp>
#include <seqan3/range/views/take.hpp>
#include <seqan3/range/views/type_reduce.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/iterator>
#include <seqan3/std/ranges>
#include <seqan3/std/span>
#include <seqan3/std/type_traits>
 
namespace seqan3::detail
{
 
// ============================================================================
//  slice_fn (adaptor definition)
// ============================================================================
 
struct slice_fn
{
    constexpr auto operator()(ptrdiff_t begin_pos, ptrdiff_t end_pos) const noexcept
    {
        return detail::adaptor_from_functor{*this, begin_pos, end_pos};
    }
 
    template <std::ranges::viewable_range urng_t>
    constexpr auto operator()(urng_t && urange,
                              std::ranges::range_difference_t<urng_t> begin_pos,
                              std::ranges::range_difference_t<urng_t> end_pos) const
    {
        using position_t = std::ranges::range_difference_t<urng_t>;
        if constexpr (std::ranges::sized_range<urng_t>)
        {
            position_t urange_size = static_cast<position_t>(std::ranges::size(urange));
 
            begin_pos = std::min(begin_pos, urange_size);
            end_pos = std::min(end_pos, urange_size);
        }
        position_t target_size = end_pos - begin_pos;
 
        if (end_pos < begin_pos)
            throw std::invalid_argument{"end_pos argument to seqan3::views::slice must be >= the begin_pos argument."};
 
        // SEQAN3_WORKAROUND_GCC_100139 == 1 if std::views::{take, drop} does not type reduce (e.g. keep in type
        // std::basic_string_view, std::span, std::ranges::subrange).
        // See https://github.com/seqan/seqan3/pull/2540/files#r617575294
#if SEQAN3_WORKAROUND_GCC_100139
        // string_view
        if constexpr (is_type_specialisation_of_v<std::remove_cvref_t<urng_t>, std::basic_string_view>)
        {
            return urange.substr(begin_pos, static_cast<size_t>(target_size));
        }
        // string const &
        else if constexpr (is_type_specialisation_of_v<std::remove_cvref_t<urng_t>, std::basic_string> &&
                           std::is_const_v<std::remove_reference_t<urng_t>>)
        {
            return std::basic_string_view{std::ranges::data(urange) + begin_pos, static_cast<size_t>(target_size)};
        }
        // contiguous
        else if constexpr (std::ranges::borrowed_range<urng_t> &&
                           std::ranges::contiguous_range<urng_t> &&
                           std::ranges::sized_range<urng_t>)
        {
            return std::span{std::ranges::data(urange) + begin_pos, static_cast<size_t>(target_size)};
        }
        // random_access
        else if constexpr (std::ranges::borrowed_range<urng_t> &&
                           std::ranges::random_access_range<urng_t> &&
                           std::ranges::sized_range<urng_t>)
        {
            return std::ranges::subrange<std::ranges::iterator_t<urng_t>, std::ranges::iterator_t<urng_t>>
            {
                std::ranges::begin(urange) + begin_pos,
                std::ranges::begin(urange) + end_pos,
                static_cast<size_t>(target_size)
            };
        }
        // std::views::drop
        else
        {
            // urange | drop | take
            return std::views::take(std::views::drop(std::forward<urng_t>(urange), begin_pos), target_size);
        }
#else // ^^^ workaround / no workaround vvv
        // urange | type_reduce | drop | take
        return std::views::take(std::views::drop(seqan3::views::type_reduce(std::forward<urng_t>(urange)),
                                                 begin_pos),
                                target_size);
#endif // SEQAN3_WORKAROUND_GCC_100139
    }
};
 
} // namespace seqan3::detail
 
// ============================================================================
//  views::slice (adaptor instance definition)
// ============================================================================
 
namespace seqan3::views
{
 
inline constexpr auto slice = detail::slice_fn{};
 
 
} // namespace seqan3::views