pod_tuple.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 <tuple>
#include <type_traits>
 
#include <seqan3/core/platform.hpp>
#include <seqan3/core/type_list/traits.hpp>
 
namespace seqan3
{
 
#define SEQAN_NOT_POD "If you are not going to insert a POD type, use std::tuple instead."
 
template <typename ...types>
struct pod_tuple
{};
 
template <typename type0, typename ...types>
struct pod_tuple<type0, types...>
{
    static_assert(std::is_standard_layout_v<type0> && std::is_trivial_v<type0>, SEQAN_NOT_POD);
    type0 _head;
    pod_tuple<types...> _tail;
 
    constexpr bool operator==(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) == std::tie(rhs._head, rhs._tail);
    }
 
    constexpr bool operator!=(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) != std::tie(rhs._head, rhs._tail);
    }
 
    constexpr bool operator<(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) < std::tie(rhs._head, rhs._tail);
    }
 
    constexpr bool operator>(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) > std::tie(rhs._head, rhs._tail);
    }
 
    constexpr bool operator<=(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) <= std::tie(rhs._head, rhs._tail);
    }
 
    constexpr bool operator>=(pod_tuple const & rhs) const noexcept
    {
        return std::tie(_head, _tail) >= std::tie(rhs._head, rhs._tail);
    }
};
 
template <typename type0>
struct pod_tuple<type0>
{
    static_assert(std::is_standard_layout_v<type0> && std::is_trivial_v<type0>, SEQAN_NOT_POD);
    type0 _head;
 
    constexpr bool operator==(pod_tuple const & rhs) const noexcept
    {
        return _head == rhs._head;
    }
 
    constexpr bool operator!=(pod_tuple const & rhs) const noexcept
    {
        return _head != rhs._head;
    }
 
    constexpr bool operator<(pod_tuple const & rhs) const noexcept
    {
        return _head < rhs._head;
    }
 
    constexpr bool operator>(pod_tuple const & rhs) const noexcept
    {
        return _head > rhs._head;
    }
 
    constexpr bool operator<=(pod_tuple const & rhs) const noexcept
    {
        return _head <= rhs._head;
    }
 
    constexpr bool operator>=(pod_tuple const & rhs) const noexcept
    {
        return _head >= rhs._head;
    }
};
 
#undef SEQAN_NOT_POD
 
template <typename ...types>
pod_tuple(types && ...) -> pod_tuple<types...>;
 
template <std::size_t i, typename ...types>
constexpr auto & get(seqan3::pod_tuple<types...> & t) noexcept
    requires (i < sizeof...(types))
{
    if constexpr (i == 0)
        return t._head;
    else
        return seqan3::get<i-1>(t._tail);
}
 
template <std::size_t i, typename ...types>
constexpr auto const & get(seqan3::pod_tuple<types...> const & t) noexcept
    requires (i < sizeof...(types))
{
    if constexpr (i == 0)
        return t._head;
    else
        return seqan3::get<i-1>(t._tail);
}
 
// extra overloads for temporaries required, because members of temporaries may only be returned as temporaries
template <std::size_t i, typename ...types>
constexpr auto && get(seqan3::pod_tuple<types...> && t) noexcept
    requires (i < sizeof...(types))
{
    if constexpr (i == 0)
        return std::move(t._head);
    else
        return seqan3::get<i-1>(std::move(t._tail));
}
 
template <std::size_t i, typename ...types>
constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
    requires (i < sizeof...(types))
{
    if constexpr (i == 0)
        return std::move(t._head);
    else
        return seqan3::get<i-1>(std::move(t._tail));
}
 
template <typename type, typename ...arg_types>
constexpr auto & get(seqan3::pod_tuple<arg_types...> & t) noexcept
    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
{
    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(t);
}
 
template <typename type, typename ...arg_types>
constexpr auto const & get(seqan3::pod_tuple<arg_types...> const & t) noexcept
    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
{
    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(t);
}
 
template <typename type, typename ...arg_types>
constexpr auto && get(seqan3::pod_tuple<arg_types...> && t) noexcept
    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
{
    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(std::move(t));
}
 
template <typename type, typename ...arg_types>
constexpr auto const && get(seqan3::pod_tuple<arg_types...> const && t) noexcept
    requires (seqan3::pack_traits::count<type, arg_types...> == 1)
{
    return seqan3::get<seqan3::pack_traits::find<type, arg_types...>>(std::move(t));
}
 
} // namespace seqan3
 
namespace std
{
 
template <std::size_t i, typename ...types>
constexpr auto & get(seqan3::pod_tuple<types...> & t) noexcept
    requires (i < sizeof...(types))
{
    return seqan3::get<i>(t);
}
 
template <std::size_t i, typename ...types>
constexpr auto const & get(seqan3::pod_tuple<types...> const & t) noexcept
    requires (i < sizeof...(types))
{
    return seqan3::get<i>(t);
}
 
template <std::size_t i, typename ...types>
constexpr auto && get(seqan3::pod_tuple<types...> && t) noexcept
    requires (i < sizeof...(types))
{
    return seqan3::get<i>(std::move(t));
}
 
template <std::size_t i, typename ...types>
constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
    requires (i < sizeof...(types))
{
    return seqan3::get<i>(std::move(t));
}
 
template <typename type, typename ...types>
constexpr auto & get(seqan3::pod_tuple<types...> & t) noexcept
    requires (seqan3::pack_traits::count<type, types...> == 1)
{
    return seqan3::get<type>(t);
}
 
template <typename type, typename ...types>
constexpr auto const & get(seqan3::pod_tuple<types...> const & t) noexcept
    requires (seqan3::pack_traits::count<type, types...> == 1)
{
    return seqan3::get<type>(t);
}
 
template <typename type, typename ...types>
constexpr auto && get(seqan3::pod_tuple<types...> && t) noexcept
    requires (seqan3::pack_traits::count<type, types...> == 1)
{
    return seqan3::get<type>(std::move(t));
}
 
template <typename type, typename ...types>
constexpr auto const && get(seqan3::pod_tuple<types...> const && t) noexcept
    requires (seqan3::pack_traits::count<type, types...> == 1)
{
    return seqan3::get<type>(std::move(t));
}
 
template <std::size_t i, template <typename ...> typename t, typename ...types>
    requires (i < sizeof...(types)) &&
            std::is_base_of_v<seqan3::pod_tuple<types...>, t<types...>>
struct tuple_element<i, t<types...>>
{
    using type = seqan3::pack_traits::at<i, types...>;
};
 
template <template <typename ...> typename t, typename ...types>
    requires std::is_base_of_v<seqan3::pod_tuple<types...>, t<types...>>
struct tuple_size<t<types...>> :
    public std::integral_constant<std::size_t, sizeof...(types)>
{};
 
} // namespace std