type_traits.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/iterator>
#include <seqan3/std/ranges>
#include <type_traits>
 
#include <seqan3/core/detail/iterator_traits.hpp>
#include <seqan3/core/platform.hpp>
#include <seqan3/utility/type_traits/basic.hpp>
#include <seqan3/utility/type_traits/pre.hpp>
 
// TODO(h-2): add innermost_reference instead of or addition to range_innermost_value?
 
//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_range_value_type = requires { typename std::ranges::range_value_t<std::remove_cvref_t<t>>; };
 
template <bool const_range, typename range_t>
using maybe_const_range_t = std::conditional_t<const_range, range_t const, range_t>;
 
template <bool const_range, typename range_t>
using maybe_const_iterator_t = std::ranges::iterator_t<maybe_const_range_t<const_range, range_t>>;
 
template <bool const_v, typename range_t>
using maybe_const_sentinel_t = std::ranges::sentinel_t<maybe_const_range_t<const_v, range_t>>;
} // namespace seqan3::detail
 
namespace seqan3
{
 
// ----------------------------------------------------------------------------
// value_type
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
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>>;
};
} // namespace seqan3::detail
#endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// reference
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
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>>;
};
 } // namespace seqan3::detail
 #endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// rvalue_reference
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
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>>;
};
} // namespace seqan3::detail
#endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// const_reference
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
template <std::ranges::input_range rng_t>
    requires (!std::input_or_output_iterator<rng_t>)
struct const_reference<rng_t>
{
    using type = std::iter_reference_t<std::ranges::iterator_t<rng_t const>>;
};
} // namespace seqan3::detail
#endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// difference_type
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
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>>;
};
} // namespace seqan3::detail
#endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// size_type
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace detail
{
template <std::ranges::sized_range rng_t>
    requires (!std::input_or_output_iterator<rng_t>)
struct size_type<rng_t>
{
    using type = decltype(std::ranges::size(std::declval<rng_t &>()));
};
} // namespace seqan3::detail
#endif // SEQAN3_DEPRECATED_310
 
// ----------------------------------------------------------------------------
// 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
// ----------------------------------------------------------------------------
 
//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>
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 [DEPRECATED]
// ----------------------------------------------------------------------------
 
#ifdef SEQAN3_DEPRECATED_310
namespace deprecated
{
template <typename t1, typename t2>
SEQAN3_CONCEPT range_compatible_concept = 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 seqan3::deprecated
 
template <typename t1, typename t2>
SEQAN3_DEPRECATED_310 constexpr bool range_compatible = deprecated::range_compatible_concept<t1, t2>;
#endif // SEQAN3_DEPRECATED_310
 
 
} // namespace seqan3