Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <tuple>
       8             : #include <utility>
       9             : 
      10             : #include "Utilities/Gsl.hpp"
      11             : #include "Utilities/TMPL.hpp"
      12             : 
      13             : namespace split_tuple_detail {
      14             : template <size_t Offset, size_t... Indices, typename... TupleTypes>
      15             : constexpr std::tuple<
      16             :     std::tuple_element_t<Offset + Indices, std::tuple<TupleTypes...>>...>
      17             : extract_subset(
      18             :     std::index_sequence<Indices...> /*meta*/,
      19             :     [[maybe_unused]] const gsl::not_null<std::tuple<TupleTypes...>*> tuple) {
      20             :   return {std::forward<
      21             :       std::tuple_element_t<Offset + Indices, std::tuple<TupleTypes...>>>(
      22             :       std::get<Offset + Indices>(*tuple))...};
      23             : }
      24             : 
      25             : template <typename... Offsets, typename... Sizes, typename... TupleTypes>
      26             : constexpr auto impl(tmpl::list<Offsets...> /*meta*/,
      27             :                     tmpl::list<Sizes...> /*meta*/,
      28             :                     [[maybe_unused]] std::tuple<TupleTypes...> tuple) {
      29             :   static_assert((0 + ... + Sizes::value) == sizeof...(TupleTypes),
      30             :                 "Tuple size does not match output sizes.");
      31             :   return std::make_tuple(extract_subset<Offsets::value>(
      32             :       std::make_index_sequence<Sizes::value>{}, make_not_null(&tuple))...);
      33             : }
      34             : }  // namespace split_tuple_detail
      35             : 
      36             : /// \ingroup UtilitiesGroup
      37             : /// Split a `std::tuple` into multiple tuples
      38             : ///
      39             : /// \note There are two functions with this name, but doxygen can't
      40             : /// figure that out.  They have signatures
      41             : /// ```
      42             : /// template <typename SizeList, typename... TupleTypes>
      43             : /// constexpr auto split_tuple(std::tuple<TupleTypes...> tuple);
      44             : /// template <size_t... Sizes, typename... TupleTypes>
      45             : /// constexpr auto split_tuple(std::tuple<TupleTypes...> tuple);
      46             : /// ```
      47             : ///
      48             : /// Given a list of sizes, either directly as template parameters or
      49             : /// as a typelist of integral constant types, split the passed tuple
      50             : /// into pieces containing the specified number of entries.  The
      51             : /// passed sizes must sum to the size of the tuple.
      52             : ///
      53             : /// \returns a `std::tuple` of `std::tuple`s
      54             : ///
      55             : /// \see std::tuple_cat for the inverse operation.
      56             : ///
      57             : /// \snippet Utilities/Test_SplitTuple.cpp split_tuple
      58             : /// @{
      59             : template <typename SizeList, typename... TupleTypes>
      60           1 : constexpr auto split_tuple(std::tuple<TupleTypes...> tuple) {
      61             :   using offsets = tmpl::pop_back<
      62             :       tmpl::fold<SizeList, tmpl::list<tmpl::size_t<0>>,
      63             :                  tmpl::bind<tmpl::push_back, tmpl::_state,
      64             :                             tmpl::plus<tmpl::bind<tmpl::back, tmpl::_state>,
      65             :                                        tmpl::_element>>>>;
      66             :   return split_tuple_detail::impl(offsets{}, SizeList{}, std::move(tuple));
      67             : }
      68             : 
      69             : template <size_t... Sizes, typename... TupleTypes>
      70             : constexpr auto split_tuple(std::tuple<TupleTypes...> tuple) {
      71             :   return split_tuple<tmpl::list<tmpl::size_t<Sizes>...>>(std::move(tuple));
      72             : }
      73             : /// @}