traits.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <type_traits>
 
#include <bio/meta/type_list/traits_detail.hpp>
#include <bio/meta/type_list/type_list.hpp>
 
// ----------------------------------------------------------------------------
// bio::meta::list_traits::detail
// ----------------------------------------------------------------------------
 
namespace bio::meta::list_traits::detail
{
 
template <ptrdiff_t idx, typename... pack_t>
std::type_identity<meta::detail::pack_traits::at<idx, pack_t...>> at(type_list<pack_t...>);
 
template <typename... pack_t>
std::type_identity<meta::detail::pack_traits::front<pack_t...>> front(type_list<pack_t...>);
 
template <typename... pack_t>
std::type_identity<meta::detail::pack_traits::back<pack_t...>> back(type_list<pack_t...>);
 
template <typename... pack1_t, typename... pack2_t>
type_list<pack1_t..., pack2_t...> concat(type_list<pack1_t...>, type_list<pack2_t...>);
 
template <typename... pack1_t, typename... pack2_t, typename... more_lists_t>
auto concat(type_list<pack1_t...>, type_list<pack2_t...>, more_lists_t...)
{
    return concat(type_list<pack1_t..., pack2_t...>{}, more_lists_t{}...);
}
 
template <typename... pack_t>
meta::detail::pack_traits::drop_front<pack_t...> drop_front(type_list<pack_t...>);
 
template <template <typename> typename trait_t, typename... pack_t>
meta::detail::pack_traits::transform<trait_t, pack_t...> transform(type_list<pack_t...>);
 
template <ptrdiff_t idx, typename... pack1_t>
meta::detail::pack_traits::split_after<idx, pack1_t...> split_after(type_list<pack1_t...>);
 
template <size_t count, typename t>
auto repeat()
{
    if constexpr (count == 0)
        return type_list<>{};
    else if constexpr (count == 1)
        return type_list<t>{};
    else if constexpr (count == 2)
        return type_list<t, t>{};
    else if constexpr (count == 3)
        return type_list<t, t, t>{};
    else if constexpr (count == 4)
        return type_list<t, t, t, t>{};
    else if constexpr (count == 5)
        return type_list<t, t, t, t, t>{};
    else
        return concat(repeat<5, t>(), repeat<count - 5, t>());
}
 
template <typename replace_t, ptrdiff_t idx, typename... pack_t>
meta::detail::pack_traits::replace_at<replace_t, idx, pack_t...> replace_at(type_list<pack_t...>);
 
inline constexpr type_list<> reverse(type_list<>)
{
    return {};
}
 
template <typename head_t, typename... pack_t>
auto reverse(type_list<head_t, pack_t...>)
{
    return concat(reverse(type_list<pack_t...>{}), type_list<head_t>{});
}
 
template <typename... current_list_t>
constexpr type_list<current_list_t...> type_list_difference(type_list<current_list_t...>, type_list<>)
{
    return {};
}
 
template <typename... current_list_t, typename remove_t, typename... remove_list_t>
constexpr auto type_list_difference(meta::type_list<current_list_t...>, meta::type_list<remove_t, remove_list_t...>)
{
    constexpr auto pos = meta::detail::pack_traits::find<remove_t, current_list_t...>;
    if constexpr (pos >= 0)
    {
        using split_list_t = meta::detail::pack_traits::split_after<pos, current_list_t...>;
 
        using split_list1_t   = typename split_list_t::first_type;
        using split_list2_t   = decltype(drop_front(typename split_list_t::second_type{}));
        using filtered_list_t = decltype(concat(split_list1_t{}, split_list2_t{}));
        return type_list_difference(filtered_list_t{}, meta::type_list<remove_t, remove_list_t...>{});
    }
    else
    {
        // remove_t not contained in current_list_t
        using filtered_list_t = meta::type_list<current_list_t...>;
        return type_list_difference(filtered_list_t{}, meta::type_list<remove_list_t...>{});
    }
}
 
} // namespace bio::meta::list_traits::detail
 
// ----------------------------------------------------------------------------
// bio::meta::list_traits
// ----------------------------------------------------------------------------
 
namespace bio::meta::list_traits
{
 
template <typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
inline constexpr size_t size = 0;
 
template <typename... pack_t>
inline constexpr size_t size<type_list<pack_t...>> = sizeof...(pack_t);
 
template <typename query_t, typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
inline constexpr ptrdiff_t count = -1;
 
template <typename query_t, typename... pack_t>
inline constexpr ptrdiff_t count<query_t, type_list<pack_t...>> = meta::detail::pack_traits::count<query_t, pack_t...>;
 
template <typename query_t, typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
inline constexpr ptrdiff_t find = -1;
 
template <typename query_t, typename... pack_t>
inline constexpr ptrdiff_t find<query_t, type_list<pack_t...>> =
  meta::detail::pack_traits::detail::find<query_t, pack_t...>();
 
template <template <typename> typename pred_t, typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
inline constexpr ptrdiff_t find_if = -1;
 
template <template <typename> typename pred_t, typename... pack_t>
inline constexpr ptrdiff_t find_if<pred_t, type_list<pack_t...>> =
  meta::detail::pack_traits::detail::find_if<pred_t, pack_t...>();
 
template <typename query_t, typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
inline constexpr bool contains = (find<query_t, list_t> != -1);
 
 
template <ptrdiff_t idx, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) &&
             ((idx >= 0 && idx < size<list_t>) || (-idx <= size<list_t>)))
using at = typename decltype(detail::at<idx>(list_t{}))::type;
 
template <typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (size<list_t> > 0))
using front = typename decltype(detail::front(list_t{}))::type;
 
template <typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (size<list_t> > 0))
using back = typename decltype(detail::back(list_t{}))::type;
 
 
template <typename... lists_t>
    requires((template_specialisation_of<lists_t, meta::type_list> && ...))
using concat = decltype(detail::concat(lists_t{}...));
 
template <typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (size<list_t> > 0))
using drop_front = decltype(detail::drop_front(list_t{}));
 
template <ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i <= size<list_t>))
using take = typename decltype(detail::split_after<i>(list_t{}))::first_type;
 
template <ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i <= size<list_t>))
using drop = typename decltype(detail::split_after<i>(list_t{}))::second_type;
 
template <ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i <= size<list_t>))
using take_last = drop<size<list_t> - i, list_t>;
 
template <ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i <= size<list_t>))
using drop_last = take<size<list_t> - i, list_t>;
 
template <ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i <= size<list_t>))
using split_after = decltype(detail::split_after<i>(list_t{}));
 
template <template <typename> typename trait_t, typename list_t>
    requires template_specialisation_of<list_t, meta::type_list>
using transform = decltype(detail::transform<trait_t>(list_t{}));
 
template <typename replace_t, std::ptrdiff_t i, typename list_t>
    requires((template_specialisation_of<list_t, meta::type_list>) && (i >= 0 && i < size<list_t>))
using replace_at = decltype(detail::replace_at<replace_t, i>(list_t{}));
 
template <size_t count, typename t>
using repeat = decltype(detail::repeat<count, t>());
 
} // namespace bio::meta::list_traits