Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines function make_array.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <array>
      10             : #include <cstddef>
      11             : #include <iterator>
      12             : #include <utility>
      13             : 
      14             : #include "Utilities/ForceInline.hpp"
      15             : #include "Utilities/Requires.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : #include "Utilities/TypeTraits.hpp"
      18             : 
      19             : // Much of this is taken from
      20             : // http://stackoverflow.com/questions/1065774/initialization-of
      21             : //     -a-normal-array-with-one-default-value
      22             : // with some modifications.
      23             : namespace MakeArray_detail {
      24             : // We handle the zero size case separately below because both for size zero
      25             : // and size one arrays the index_sequence is empty.
      26             : // We use the index_sequence to be able to fill the first Size-1 (which is
      27             : // sizeof...(Is)) via constructor calls `T(args...)`. The final element is
      28             : // forwarded to avoid a possible copy if an rvalue reference is passed to
      29             : // make_array. The generic implementation handles both the make_array(T&&) case
      30             : // and the make_array(Args&&...) case below.
      31             : // The (void)Is cast is to avoid any potential trouble with overloaded comma
      32             : // operators.
      33             : template <bool SizeZero>
      34             : struct MakeArray {
      35             :   template <typename T, typename... Args, size_t... Is>
      36             :   static SPECTRE_ALWAYS_INLINE constexpr std::array<T, sizeof...(Is) + 1> apply(
      37             :       std::index_sequence<Is...> /* unused */, Args&&... args) {
      38             :     return {{((void)Is, T(args...))..., T(std::forward<Args>(args)...)}};
      39             :   }
      40             : };
      41             : 
      42             : template <>
      43             : struct MakeArray<true> {
      44             :   template <typename T, typename... Args>
      45             :   static SPECTRE_ALWAYS_INLINE constexpr std::array<T, 0> apply(
      46             :       std::index_sequence<> /* unused */, Args&&... args) {
      47             : #ifndef HAVE_BROKEN_ARRAY0
      48             :     expand_pack(args...);  // Used in other preprocessor branch
      49             :     return std::array<T, 0>{{}};
      50             : #else  // HAVE_BROKEN_ARRAY0
      51             :     // https://bugs.llvm.org/show_bug.cgi?id=35491
      52             :     return {{T(std::forward<Args>(args)...)}};
      53             : #endif  // HAVE_BROKEN_ARRAY0
      54             :   }
      55             : };
      56             : }  // namespace MakeArray_detail
      57             : 
      58             : /*!
      59             :  * \ingroup UtilitiesGroup
      60             :  * \brief Create a `std::array<T, Size>{{T(args...), T(args...), ...}}`
      61             :  * \tparam Size the size of the array
      62             :  * \tparam T the type of the element in the array
      63             :  */
      64             : template <size_t Size, typename T, typename... Args>
      65           1 : SPECTRE_ALWAYS_INLINE constexpr std::array<T, Size> make_array(Args&&... args) {
      66             :   return MakeArray_detail::MakeArray<Size == 0>::template apply<T>(
      67             :       std::make_index_sequence<(Size == 0 ? Size : Size - 1)>{},
      68             :       std::forward<Args>(args)...);
      69             : }
      70             : 
      71             : /*!
      72             :  * \ingroup UtilitiesGroup
      73             :  * \brief Create a `std::array<std::decay_t<T>, Size>{{t, t, ...}}`
      74             :  * \tparam Size the size of the array
      75             :  */
      76             : template <size_t Size, typename T>
      77           1 : SPECTRE_ALWAYS_INLINE constexpr auto make_array(T&& t)
      78             :     -> std::array<std::decay_t<T>, Size> {
      79             :   return MakeArray_detail::MakeArray<Size == 0>::template apply<
      80             :       std::decay_t<T>>(
      81             :       std::make_index_sequence<(Size == 0 ? Size : Size - 1)>{},
      82             :       std::forward<T>(t));
      83             : }
      84             : 
      85             : /*!
      86             :  * \ingroup UtilitiesGroup
      87             :  * \brief Helper function to initialize a std::array with varying number of
      88             :  * arguments
      89             :  */
      90             : template <typename T, typename... V, Requires<(sizeof...(V) > 0)> = nullptr>
      91           1 : SPECTRE_ALWAYS_INLINE constexpr auto make_array(T&& t, V&&... values)
      92             :     -> std::array<typename std::decay_t<T>, sizeof...(V) + 1> {
      93             :   static_assert(
      94             :       tmpl2::flat_all_v<std::is_same_v<std::decay_t<T>, std::decay_t<V>>...>,
      95             :       "all types to make_array(...) must be the same");
      96             :   return std::array<std::decay_t<T>, sizeof...(V) + 1>{
      97             :       {std::forward<T>(t), std::forward<V>(values)...}};
      98             : }
      99             : 
     100             : namespace MakeArray_detail {
     101             : template <typename Seq, typename T,
     102             :           Requires<std::is_rvalue_reference_v<Seq>> = nullptr>
     103             : constexpr T&& forward_element(T& t) {
     104             :   return std::move(t);
     105             : }
     106             : template <typename Seq, typename T,
     107             :           Requires<not std::is_rvalue_reference_v<Seq>> = nullptr>
     108             : constexpr T& forward_element(T& t) {
     109             :   return t;
     110             : }
     111             : 
     112             : template <typename T, size_t size, typename Seq, size_t... indexes>
     113             : constexpr std::array<T, size> make_array_from_iterator_impl(
     114             :     Seq&& s, std::integer_sequence<size_t, indexes...> /*meta*/) {
     115             :   // clang-tidy: do not use pointer arithmetic
     116             :   return std::array<T, size>{
     117             :       {forward_element<decltype(s)>(*(std::begin(s) + indexes))...}};  // NOLINT
     118             : }
     119             : }  // namespace MakeArray_detail
     120             : 
     121             : /*!
     122             :  * \ingroup UtilitiesGroup
     123             :  * \brief Create an `std::array<T, size>` from the first `size` values of `seq`
     124             :  *
     125             :  * \requires `Seq` has a `begin` function
     126             :  * \tparam T the type held by the array
     127             :  * \tparam size the size of the created array
     128             :  */
     129             : template <typename T, size_t size, typename Seq>
     130           1 : constexpr std::array<T, size> make_array(Seq&& seq) {
     131             :   return MakeArray_detail::make_array_from_iterator_impl<T, size>(
     132             :       std::forward<Seq>(seq), std::make_index_sequence<size>{});
     133             : }