range.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 <type_traits>
 
#include <seqan3/core/platform.hpp>
#include <seqan3/core/type_traits/pre.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/iterator.hpp>
#include <seqan3/range/shortcuts.hpp>
#include <seqan3/std/ranges>
#include <seqan3/std/iterator>
 
// TODO(h-2): add innermost_reference instead of or addition to innermost_value_type?
 
//NOTE(h-2): for the range overloads we explicitly forbid that the type is iteratoer
// because some types are actually both (e.g. std::directory_iterator)
 
namespace seqan3::detail
{
 
template <typename t>
SEQAN3_CONCEPT has_value_type = requires { typename value_type_t<remove_cvref_t<t>>; };
 
} // namespace seqan3::detail
 
namespace seqan3
{
 
// ----------------------------------------------------------------------------
// value_type
// ----------------------------------------------------------------------------
 
template <std::ranges::input_range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct value_type<rng_t>
{
    using type = value_type_t<std::ranges::iterator_t<rng_t>>;
};
 
// ----------------------------------------------------------------------------
// reference
// ----------------------------------------------------------------------------
 
template <std::ranges::input_range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct reference<rng_t>
{
    using type = reference_t<std::ranges::iterator_t<rng_t>>;
};
 
// ----------------------------------------------------------------------------
// rvalue_reference
// ----------------------------------------------------------------------------
 
template <std::ranges::input_range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct rvalue_reference<rng_t>
{
    using type = rvalue_reference_t<std::ranges::iterator_t<rng_t>>;
};
 
// ----------------------------------------------------------------------------
// const_reference
// ----------------------------------------------------------------------------
 
template <std::ranges::input_range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct const_reference<rng_t>
{
    using type = reference_t<std::ranges::iterator_t<rng_t const>>;
};
 
// ----------------------------------------------------------------------------
// difference_type
// ----------------------------------------------------------------------------
 
template <std::ranges::range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct difference_type<rng_t>
{
    using type = difference_type_t<std::ranges::iterator_t<rng_t>>;
};
 
// ----------------------------------------------------------------------------
// size_type
// ----------------------------------------------------------------------------
 
template <std::ranges::sized_range rng_t>
    requires !std::input_or_output_iterator<rng_t>
struct size_type<rng_t>
{
    using type = decltype(size(std::declval<rng_t &>()));
};
 
// ----------------------------------------------------------------------------
// innermost_value_type
// ----------------------------------------------------------------------------
 
//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
 
template <typename t>
    requires detail::has_value_type<t>
struct innermost_value_type
{
    using type = value_type_t<remove_cvref_t<t>>;
};
 
template <typename t>
    requires detail::has_value_type<t> && detail::has_value_type<value_type_t<remove_cvref_t<t>>>
struct innermost_value_type<t>
{
    using type = typename innermost_value_type<value_type_t<remove_cvref_t<t>>>::type;
};
 
template <typename t>
using innermost_value_type_t = typename innermost_value_type<t>::type;
 
// ----------------------------------------------------------------------------
// dimension_v
// ----------------------------------------------------------------------------
 
//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
 
template <typename t>
    requires detail::has_value_type<t>
constexpr size_t dimension_v = 1;
 
template <typename t>
    requires detail::has_value_type<t> && detail::has_value_type<value_type_t<remove_cvref_t<t>>>
constexpr size_t dimension_v<t> = dimension_v<value_type_t<remove_cvref_t<t>>> + 1;
 
// ----------------------------------------------------------------------------
// compatible
// ----------------------------------------------------------------------------
 
//NOTE(h-2): this could be moved to a separate file, because it also applies to iterators
 
template <typename t1, typename t2>
SEQAN3_CONCEPT compatible = requires (t1, t2)
{
    requires (dimension_v<t1> == dimension_v<t2>);
 
    requires std::is_same_v<innermost_value_type_t<t1>, innermost_value_type_t<t2>>;
};
 
 
} // namespace seqan3