tuple.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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 <tuple>
#include <type_traits>

#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/core/type_list.hpp>
#include <seqan3/core/pod_tuple.hpp>
#include <seqan3/std/concepts>

namespace seqan3::detail
{

template <typename tuple_t>
SEQAN3_CONCEPT TupleSize = requires (tuple_t v)
{
    { std::tuple_size<tuple_t>::value } -> size_t;
};

template <typename tuple_t>
SEQAN3_CONCEPT TupleGet = 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)              } -> typename std::tuple_element<0, tuple_t>::type;
//     requires WeaklyAssignable<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 requires lvalue-reference, but we want to accept xvalues too (returned proxies)
    { get<0>(v_c)            } -> typename std::tuple_element<0, tuple_t>::type;
    { get<0>(std::move(v))   } -> typename std::tuple_element<0, tuple_t>::type;
    // TODO: The return type for std::tuple is wrong until gcc-8.0, for gcc > 8.0 this is fixed.
    { get<0>(std::move(v_c)) };// -> typename std::tuple_element<0, tuple_t>::type const &&;
};

template <typename state_t, typename element_t>
struct models_strict_totally_ordered
{
    using type =  std::conditional_t<state_t::value && std::StrictTotallyOrdered<element_t>,
                                    std::true_type,
                                    std::false_type>;
};

template <detail::TupleSize 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::TupleSize tuple_t>
using tuple_type_list_t = typename tuple_type_list<tuple_t>::type;
} // namespace::seqan3

namespace seqan3
{

// ----------------------------------------------------------------------------
// TupleLike
// ----------------------------------------------------------------------------

template <typename t>
SEQAN3_CONCEPT TupleLike = detail::TupleSize<std::remove_reference_t<t>> && requires(t v)
{
    typename detail::tuple_type_list<remove_cvref_t<t>>::type;

    // NOTE(rrahn): To check the full tuple_concept including the get interface and the std::StrictTotallyOrdered
    //              we need to make some assumptions. In general these checks can only be executed if the tuple is not
    //              empty. Furthermore, the std::StrictTotallyOrdered 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::TupleGet<remove_cvref_t<t>> &&
                (!meta::fold<detail::tuple_type_list_t<remove_cvref_t<t>>,
                             std::true_type,
                             meta::quote_trait<detail::models_strict_totally_ordered>>::value ||
                std::StrictTotallyOrdered<remove_cvref_t<t>>);
};

} // namespace seqan3