Make the arrays in try_lock_until_impl constexpr

This is probably unnecessary but makes it clear that is possible
to create them at compile time.

Signed-off-by: Ted Lyngmo <[email protected]>

Author: TedLyngmo

include/beman/timed_lock_alg/mutex.hpp

@@ -68,22 +68,24 @@ struct result {
 template <class Timepoint, class Locks, class... Seqs>
 int try_lock_until_impl(const Timepoint& end_time, Locks locks, type_pack<Seqs...>) {
     // an array with one function per lockable/sequence to try:
-    std::array<result (*)(const Timepoint&, Locks&), sizeof...(Seqs)> seqs{{+[](const Timepoint& tp, Locks& lks) {
-        return []<class Tp, std::size_t I0, std::size_t... Is>(
-                   const Tp& itp, Locks& lcks, std::index_sequence<I0, Is...>) -> result {
-            if (std::unique_lock first{std::get<I0>(lcks), itp}) {
-                int res = friendly_try_lock(std::get<Is>(lcks)...);
-                if (res == -1) {
-                    first.release();
-                    return {-1, false}; // success
+    constexpr std::array<result (*)(const Timepoint&, Locks&), sizeof...(Seqs)> seqs{
+        {+[](const Timepoint& tp, Locks& lks) {
+            return []<class Tp, std::size_t I0, std::size_t... Is>(
+                       const Tp& itp, Locks& lcks, std::index_sequence<I0, Is...>) -> result {
+                if (std::unique_lock first{std::get<I0>(lcks), itp}) {
+                    int res = friendly_try_lock(std::get<Is>(lcks)...);
+                    if (res == -1) {
+                        first.release();
+                        return {-1, false}; // success
+                    }
+                    // return the index to try_lock_until next round
+                    constexpr std::array idxs{static_cast<int>(Is)...};
+                    return {idxs[static_cast<std::size_t>(res)], true};
                 }
-                // return the index to try_lock_until next round
-                return {static_cast<int>(std::array{Is...}[static_cast<std::size_t>(res)]), true};
-            }
-            // timeout
-            return {static_cast<int>(I0), false};
-        }(tp, lks, Seqs{});
-    }...}};
+                // timeout
+                return {static_cast<int>(I0), false};
+            }(tp, lks, Seqs{});
+        }...}};
 
     // try rotations in seqs while there is time to retry
     result ret{};