tuple.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 <concepts>
#include <tuple>
#include <type_traits>
 
#include <bio/meta/pod_tuple.hpp>
#include <bio/meta/type_list/type_list.hpp>
#include <bio/meta/type_traits/basic.hpp>
#include <bio/meta/type_traits/template_inspection.hpp>
 
namespace bio::meta::detail
{
 
template <typename tuple_t>
concept tuple_size = requires(tuple_t v) {
    {
        std::tuple_size<tuple_t>::value
    } -> std::convertible_to<size_t>;
};
 
template <typename tuple_t>
concept tuple_get = requires(tuple_t & v, tuple_t const & v_c) {
    requires std::tuple_size_v<tuple_t> > 0;
 
    typename std::tuple_element<0, tuple_t>::type;
 
    {
        get<0>(v)
    } -> std::convertible_to<typename std::tuple_element<0, tuple_t>::type>;
    //     requires weakly_assignable_from<decltype(get<0>(v)), typename std::tuple_element<0, tuple_t>::type>;
    //TODO check that the previous returns something that can be assigned to
    // unfortunately std::assignable_from requires lvalue-reference, but we want to accept xvalues too (returned
    // proxies)
    {
        get<0>(v_c)
    } -> std::convertible_to<typename std::tuple_element<0, tuple_t>::type>;
    {
        get<0>(std::move(v))
    } -> std::convertible_to<typename std::tuple_element<0, tuple_t>::type>;
    {
        get<0>(std::move(v_c))
    } -> std::convertible_to<typename std::tuple_element<0, tuple_t>::type const &&>;
};
 
template <detail::tuple_size tuple_t>
struct tuple_type_list
{
protected:
    template <size_t... Is>
    static constexpr auto invoke_to_type_list(std::index_sequence<Is...>)
    {
        return type_list<std::tuple_element_t<Is, tuple_t>...>{};
    }
 
public:
    using type = decltype(invoke_to_type_list(std::make_index_sequence<std::tuple_size<tuple_t>::value>{}));
};
 
template <detail::tuple_size tuple_t>
using tuple_type_list_t = typename tuple_type_list<tuple_t>::type;
 
template <typename... elements_t>
inline constexpr auto all_elements_model_totally_ordered(meta::type_list<elements_t...>)
  -> std::bool_constant<(std::totally_ordered<elements_t> && ... && true)>;
 
template <typename tuple_t>
    requires(requires {
                {
                    detail::all_elements_model_totally_ordered(tuple_type_list_t<tuple_t>{})
                };
            })
static constexpr bool all_elements_model_totally_ordered_v =
  decltype(detail::all_elements_model_totally_ordered(tuple_type_list_t<tuple_t>{}))::value;
} // namespace bio::meta::detail
 
namespace bio::meta
{
 
// ----------------------------------------------------------------------------
// tuple_like
// ----------------------------------------------------------------------------
 
template <typename t>
concept tuple_like = detail::tuple_size<std::remove_reference_t<t>> && requires(t v) {
    typename detail::tuple_type_list<std::remove_cvref_t<t>>::type;
 
    // NOTE(rrahn): To check the full tuple_concept including the get interface and the std::totally_ordered
    //              we need to make some assumptions. In general these checks can only be executed if the tuple is not
    //              empty. Furthermore, the std::totally_ordered can only be checked if all elements in the
    //              tuple are strict_totally_ordered. This is done, by the fold expression in the second part.
    requires(std::tuple_size<std::remove_reference_t<t>>::value == 0) ||
              (detail::tuple_get<std::remove_cvref_t<t>> &&
               (!detail::all_elements_model_totally_ordered_v<std::remove_cvref_t<t>> ||
                std::totally_ordered<std::remove_cvref_t<t>>));
};
 
template <typename t>
concept pair_like = tuple_like<t> && std::tuple_size_v<std::remove_reference_t<t>> == 2;
 
} // namespace bio::meta