traits.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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/type_traits>
#include <utility>
 
#include <seqan3/utility/type_list/type_list.hpp>
 
// ----------------------------------------------------------------------------
// seqan3::pack_traits::detail
// ----------------------------------------------------------------------------
 
namespace seqan3::pack_traits::detail
{
 
template <typename query_t, typename ...pack_t>
constexpr ptrdiff_t find()
{
    ptrdiff_t i = 0;
    return ((std::is_same_v<query_t, pack_t> ? false : ++i) && ...) ? -1 : i;
}
 
template <template <typename> typename pred_t, typename ...pack_t>
constexpr ptrdiff_t find_if()
{
    ptrdiff_t i = 0;
    return ((pred_t<pack_t>::value ? false : ++i) && ...) ? -1 : i;
}
 
template <ptrdiff_t idx, typename head_t, typename ...tail_t>
auto at()
{
    if constexpr (idx == 0)
        return std::type_identity<head_t>{};
    else if constexpr (idx > 0)
#ifdef __clang__
        return std::type_identity<__type_pack_element<idx - 1, tail_t...>>{};
#else
        return at<idx - 1, tail_t...>();
#endif // __clang__
    else
        return at<sizeof...(tail_t) + 1 + idx, head_t, tail_t...>();
}
 
template <typename head_t, typename ...tail_t>
std::type_identity<head_t> front();
 
template <typename head_t, typename ...tail_t>
type_list<tail_t...> drop_front();
 
template <ptrdiff_t idx,
          typename head_t, typename ...pack2_t,
          typename ...pack1_t>
auto split_after(type_list<pack1_t...>)
{
    if constexpr (idx == sizeof...(pack2_t) + 1)
        return std::pair<type_list<pack1_t..., head_t, pack2_t...>, type_list<>>{};
    else if constexpr (idx == 0)
        return std::pair<type_list<pack1_t...>, type_list<head_t, pack2_t...>>{};
    else
        return split_after<idx - 1, pack2_t...>(type_list<pack1_t..., head_t>{});
}
 
template <typename replace_t,
          ptrdiff_t idx,
          typename ...pack_t,
          size_t ...i>
auto replace_at(std::index_sequence<i...>) -> type_list<std::conditional_t<i == idx, replace_t, pack_t>...>;
 
} // namespace seqan3::pack_traits::detail
 
// ----------------------------------------------------------------------------
// seqan3::pack_traits
// ----------------------------------------------------------------------------
 
namespace seqan3::pack_traits
{
 
template <typename ...pack_t>
inline constexpr size_t size = sizeof...(pack_t);
 
template <typename query_t, typename ...pack_t>
inline constexpr ptrdiff_t count =  (std::is_same_v<query_t, pack_t> + ... + 0);
 
template <typename query_t, typename ...pack_t>
inline constexpr ptrdiff_t find = seqan3::pack_traits::detail::find<query_t, pack_t...>();
 
template <template <typename> typename pred_t, typename ...pack_t>
inline constexpr ptrdiff_t find_if = seqan3::pack_traits::detail::find_if<pred_t, pack_t...>();
 
template <typename query_t, typename ...pack_t>
inline constexpr bool contains = (find<query_t, pack_t...> != -1);
 
template <ptrdiff_t idx, typename ...pack_t>
    requires (idx >= 0 && idx < sizeof...(pack_t)) ||
             (-idx <= sizeof...(pack_t))
using at = typename decltype(detail::at<idx, pack_t...>())::type;
 
template <typename ...pack_t>
    requires (sizeof...(pack_t) > 0)
using front = typename decltype(detail::front<pack_t...>())::type;
 
template <typename ...pack_t>
    requires (sizeof...(pack_t) > 0)
using back = typename decltype((std::type_identity<pack_t>{}, ...))::type; // use comma operator
 
 
template <typename ...pack_t>
    requires (sizeof...(pack_t) > 0)
using drop_front = typename decltype(detail::drop_front<pack_t...>())::type;
 
template <template <typename> typename trait_t, typename ...pack_t>
using transform = seqan3::type_list<trait_t<pack_t>...>;
 
 
template <ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i <= size<pack_t...>)
using take = typename decltype(detail::split_after<i, pack_t...>(type_list<>{}))::first_type;
 
template <ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i <= size<pack_t...>)
using drop = typename decltype(detail::split_after<i, pack_t...>(type_list<>{}))::second_type;
 
template <ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i <= size<pack_t...>)
using take_last = drop<size<pack_t...> - i, pack_t...>;
 
template <ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i <= size<pack_t...>)
using drop_last = take<size<pack_t...> - i, pack_t...>;
 
template <ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i <= size<pack_t...>)
using split_after = decltype(detail::split_after<i, pack_t...>(type_list<>{}));
 
 
template <typename replace_t, std::ptrdiff_t i, typename ...pack_t>
    requires (i >= 0 && i < size<pack_t...>)
using replace_at = decltype(detail::replace_at<replace_t, i, pack_t...>(std::make_index_sequence<size<pack_t...>>{}));
 
 
} // namespace seqan3::pack_traits