type_traits.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 <iterator>
#include <ranges>
#include <type_traits>
 
#include <bio/core.hpp>
#include <bio/meta/type_traits/basic.hpp>
 
namespace bio::ranges::detail
{
 
// ----------------------------------------------------------------------------
// iterator_category_tag
// ----------------------------------------------------------------------------
 
#if BIOCPP_WORKAROUND_GCC_96070
template <typename it_t>
struct iterator_category_tag
{
    using type = void;
};
 
template <typename it_t>
    requires(requires { typename std::iterator_traits<it_t>::iterator_category; })
struct iterator_category_tag<it_t>
{
    using type = typename std::iterator_traits<it_t>::iterator_category;
};
 
template <typename it_t>
using iterator_category_tag_t = typename iterator_category_tag<it_t>::type;
#else  // ^^^ workaround / no workaround vvv
// TODO: Change the description / the definition of iterator_category_tag_t depending on how the standard resolves this
// https://github.com/seqan/product_backlog/issues/151
 
template <typename it_t>
    requires(requires { typename std::iterator_traits<it_t>::iterator_category; })
using iterator_category_tag_t = typename std::iterator_traits<it_t>::iterator_category;
#endif // BIOCPP_WORKAROUND_GCC_96070
 
// ----------------------------------------------------------------------------
// iterator_concept_tag_
// ----------------------------------------------------------------------------
 
template <typename it_t>
    requires std::input_or_output_iterator<it_t>
// clang-format off
using iterator_concept_tag_t = std::conditional_t<std::contiguous_iterator<it_t>,    std::contiguous_iterator_tag,
                               std::conditional_t<std::random_access_iterator<it_t>, std::random_access_iterator_tag,
                               std::conditional_t<std::bidirectional_iterator<it_t>, std::bidirectional_iterator_tag,
                               std::conditional_t<std::forward_iterator<it_t>,       std::forward_iterator_tag,
                               std::conditional_t<std::input_iterator<it_t>,         std::input_iterator_tag,
                                                                                     std::output_iterator_tag>>>>>;
// clang-format on
 
// ----------------------------------------------------------------------------
// iter_pointer
// ----------------------------------------------------------------------------
 
template <typename it_t>
struct iter_pointer
{
    using type = void;
};
 
template <typename it_t>
    requires(requires { typename std::iterator_traits<it_t>::pointer; })
struct iter_pointer<it_t>
{
    using type = typename std::iterator_traits<it_t>::pointer;
};
 
template <typename it_t>
using iter_pointer_t = typename iter_pointer<it_t>::type;
 
template <typename t>
concept has_range_value_type = requires { typename std::ranges::range_value_t<std::remove_cvref_t<t>>; };
 
} // namespace bio::ranges::detail
 
namespace bio::ranges
{
 
// ----------------------------------------------------------------------------
// range_innermost_value
// ----------------------------------------------------------------------------
 
//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
 
template <typename t>
    requires detail::has_range_value_type<t>
struct range_innermost_value
{
    using type = std::ranges::range_value_t<std::remove_cvref_t<t>>;
};
 
template <typename t>
    requires(detail::has_range_value_type<t> &&
             detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>)
struct range_innermost_value<t>
{
    using type = typename range_innermost_value<std::ranges::range_value_t<std::remove_cvref_t<t>>>::type;
};
 
template <typename t>
using range_innermost_value_t = typename range_innermost_value<t>::type;
 
// ----------------------------------------------------------------------------
// range_dimension_v
// ----------------------------------------------------------------------------
 
template <typename t>
    requires detail::has_range_value_type<t>
constexpr size_t range_dimension_v = 1;
 
template <typename t>
    requires(detail::has_range_value_type<t> &&
             detail::has_range_value_type<std::ranges::range_value_t<std::remove_cvref_t<t>>>)
constexpr size_t range_dimension_v<t> = range_dimension_v<std::ranges::range_value_t<std::remove_cvref_t<t>>> + 1;
 
// ----------------------------------------------------------------------------
// range_compatible
// ----------------------------------------------------------------------------
 
template <typename t1, typename t2>
concept range_compatible = requires(t1, t2) {
    requires(range_dimension_v<t1> == range_dimension_v<t2>);
 
    requires std::is_same_v<range_innermost_value_t<t1>, range_innermost_value_t<t2>>;
};
 
 
} // namespace bio::ranges