pod_tuple.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// 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/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <tuple>
#include <type_traits>
 
#include <bio/meta/type_list/traits.hpp>
 
namespace bio::meta
{
 
template <typename... types>
struct pod_tuple
{};
 
template <typename type0, typename... types>
struct pod_tuple<type0, types...>
{
    type0               _head;
    pod_tuple<types...> _tail;
 
    friend bool operator==(pod_tuple const & lhs, pod_tuple const & rhs) noexcept = default;
 
    constexpr friend auto operator<=>(pod_tuple const & lhs, pod_tuple const & rhs) noexcept
    {
        return std::tie(lhs._head, lhs._tail) <=> std::tie(rhs._head, rhs._tail);
    }
};
 
template <typename type0>
struct pod_tuple<type0>
{
    type0 _head;
 
    friend bool operator==(pod_tuple const & lhs, pod_tuple const & rhs) noexcept = default;
 
    constexpr friend auto operator<=>(pod_tuple const & lhs, pod_tuple const & rhs) noexcept = default;
};
 
template <typename... types>
pod_tuple(types &&...) -> pod_tuple<types...>;
 
template <std::size_t i, typename... types>
constexpr auto & get(bio::meta::pod_tuple<types...> & t) noexcept
    requires(i < sizeof...(types))
{
    if constexpr (i == 0)
        return t._head;
    else
        return bio::meta::get<i - 1>(t._tail);
}
 
template <std::size_t i, typename... types>
constexpr auto const & get(bio::meta::pod_tuple<types...> const & t) noexcept
    requires(i < sizeof...(types))
{
    if constexpr (i == 0)
        return t._head;
    else
        return bio::meta::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(bio::meta::pod_tuple<types...> && t) noexcept
    requires(i < sizeof...(types))
{
    if constexpr (i == 0)
        return std::move(t._head);
    else
        return bio::meta::get<i - 1>(std::move(t._tail));
}
 
template <std::size_t i, typename... types>
constexpr auto const && get(bio::meta::pod_tuple<types...> const && t) noexcept
    requires(i < sizeof...(types))
{
    if constexpr (i == 0)
        return std::move(t._head);
    else
        return bio::meta::get<i - 1>(std::move(t._tail));
}
 
template <typename type, typename... arg_types>
constexpr auto & get(bio::meta::pod_tuple<arg_types...> & t) noexcept
    requires(meta::detail::pack_traits::count<type, arg_types...> == 1)
{
    return bio::meta::get<meta::detail::pack_traits::find<type, arg_types...>>(t);
}
 
template <typename type, typename... arg_types>
constexpr auto const & get(bio::meta::pod_tuple<arg_types...> const & t) noexcept
    requires(meta::detail::pack_traits::count<type, arg_types...> == 1)
{
    return bio::meta::get<meta::detail::pack_traits::find<type, arg_types...>>(t);
}
 
template <typename type, typename... arg_types>
constexpr auto && get(bio::meta::pod_tuple<arg_types...> && t) noexcept
    requires(meta::detail::pack_traits::count<type, arg_types...> == 1)
{
    return bio::meta::get<meta::detail::pack_traits::find<type, arg_types...>>(std::move(t));
}
 
template <typename type, typename... arg_types>
constexpr auto const && get(bio::meta::pod_tuple<arg_types...> const && t) noexcept
    requires(meta::detail::pack_traits::count<type, arg_types...> == 1)
{
    return bio::meta::get<meta::detail::pack_traits::find<type, arg_types...>>(std::move(t));
}
 
} // namespace bio::meta
 
namespace std
{
 
template <std::size_t i, typename... types>
constexpr auto & get(bio::meta::pod_tuple<types...> & t) noexcept
    requires(i < sizeof...(types))
{
    return bio::meta::get<i>(t);
}
 
template <std::size_t i, typename... types>
constexpr auto const & get(bio::meta::pod_tuple<types...> const & t) noexcept
    requires(i < sizeof...(types))
{
    return bio::meta::get<i>(t);
}
 
template <std::size_t i, typename... types>
constexpr auto && get(bio::meta::pod_tuple<types...> && t) noexcept
    requires(i < sizeof...(types))
{
    return bio::meta::get<i>(std::move(t));
}
 
template <std::size_t i, typename... types>
constexpr auto const && get(bio::meta::pod_tuple<types...> const && t) noexcept
    requires(i < sizeof...(types))
{
    return bio::meta::get<i>(std::move(t));
}
 
template <typename type, typename... types>
constexpr auto & get(bio::meta::pod_tuple<types...> & t) noexcept
    requires(bio::meta::detail::pack_traits::count<type, types...> == 1)
{
    return bio::meta::get<type>(t);
}
 
template <typename type, typename... types>
constexpr auto const & get(bio::meta::pod_tuple<types...> const & t) noexcept
    requires(bio::meta::detail::pack_traits::count<type, types...> == 1)
{
    return bio::meta::get<type>(t);
}
 
template <typename type, typename... types>
constexpr auto && get(bio::meta::pod_tuple<types...> && t) noexcept
    requires(bio::meta::detail::pack_traits::count<type, types...> == 1)
{
    return bio::meta::get<type>(std::move(t));
}
 
template <typename type, typename... types>
constexpr auto const && get(bio::meta::pod_tuple<types...> const && t) noexcept
    requires(bio::meta::detail::pack_traits::count<type, types...> == 1)
{
    return bio::meta::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<bio::meta::pod_tuple<types...>, t<types...>>
struct tuple_element<i, t<types...>>
{
    using type = bio::meta::detail::pack_traits::at<i, types...>;
};
 
template <template <typename...> typename t, typename... types>
    requires std::is_base_of_v<bio::meta::pod_tuple<types...>, t<types...>>
struct tuple_size<t<types...>> : public std::integral_constant<std::size_t, sizeof...(types)>
{};
 
} // namespace std