Add Array::with_values() that takes varargs for each value

Author: danakj

containers/array.h

@@ -16,6 +16,7 @@
 
 #include <stdint.h>
 
+#include <concepts>
 #include <type_traits>
 #include <utility>  // TODO: replace std::make_index_sequence.
 
@@ -69,8 +70,7 @@ class Array final {
 
   template <class InitializerFn>
   constexpr static Array with_initializer(InitializerFn f) noexcept {
-    return Array(kWithInitializer, ::sus::move(f),
-                 std::make_index_sequence<N>());
+    return Array(kWithInitializer, move(f), std::make_index_sequence<N>());
   }
 
   constexpr static Array with_value(const T& t) noexcept
@@ -79,18 +79,30 @@ class Array final {
     return Array(kWithValue, t, std::make_index_sequence<N>());
   }
 
-  constexpr const T& get(size_t i) const& noexcept
+  // Uses convertible_to<T> instead of same_as<T> to accept `sus::into()`
+  // values. But doesn't use sus::construct::Into<T> to avoid implicit
+  // conversions.
+  template <std::convertible_to<T>... Ts>
+    requires(sizeof...(Ts) == N)
+  constexpr static Array with_values(Ts... ts) noexcept {
+    auto a = Array(kWithUninitialized);
+    init_values(a.as_ptr_mut(), 0, move(ts)...);
+    return a;
+  }
+
+ public:
+  constexpr const T& get(/* TODO: usize */ size_t i) const& noexcept
     requires(N > 0)
   {
-    ::sus::check(i < N);
+    check(i < N);
     return storage_.data_[i];
   }
-  constexpr const T& get(size_t i) && = delete;
+  constexpr const T& get(/* TODO: usize */ size_t i) && = delete;
 
-  constexpr T& get_mut(size_t i) & noexcept
+  constexpr T& get_mut(/* TODO: usize */ size_t i) & noexcept
     requires(N > 0)
   {
-    ::sus::check(i < N);
+    check(i < N);
     return storage_.data_[i];
   }
 
@@ -122,14 +134,24 @@ class Array final {
   template <size_t... Is>
   constexpr Array(WithUninitialized) noexcept {}
 
+  template <std::convertible_to<T> T1, std::convertible_to<T>... Ts>
+  static inline void init_values(T* a, size_t index, T1&& t1, Ts&&... ts) {
+    new (a + index) T(move(t1));
+    init_values(a, index + 1, move(ts)...);
+  }
+  template <std::convertible_to<T> T1>
+  static inline void init_values(T* a, size_t index, T1&& t1) {
+    new (a + index) T(move(t1));
+  }
+
   // Using a union ensures that the default constructor doesn't initialize
   // anything.
   union {
     ::sus::containers::__private::Storage<T, N> storage_;
   };
 
-  sus_class_trivial_relocatable_value(
-      unsafe_fn, ::sus::mem::relocate_array_by_memcpy<T>);
+  sus_class_trivial_relocatable_value(unsafe_fn,
+                                      ::sus::mem::relocate_array_by_memcpy<T>);
 };
 
 }  // namespace sus::containers

containers/array_unittest.cc

@@ -16,8 +16,10 @@
 
 #include <type_traits>
 
+#include "construct/into.h"
 #include "marker/unsafe.h"
 #include "mem/relocate.h"
+#include "num/types.h"
 #include "third_party/googletest/googletest/include/gtest/gtest.h"
 
 using ::sus::containers::Array;
@@ -30,32 +32,32 @@ struct TriviallyRelocatable {
   int i;
 };
 
-static_assert(!std::is_trivially_constructible_v<Array<int, 2>>, "");
-static_assert(!std::is_trivial_v<Array<int, 2>>, "");
-static_assert(!std::is_aggregate_v<Array<int, 2>>, "");
-static_assert(std::is_standard_layout_v<Array<int, 2>>, "");
+static_assert(!std::is_trivially_constructible_v<Array<int, 2>>);
+static_assert(!std::is_trivial_v<Array<int, 2>>);
+static_assert(!std::is_aggregate_v<Array<int, 2>>);
+static_assert(std::is_standard_layout_v<Array<int, 2>>);
 
 // TODO: This covers a trivially relocatable type, but what about the rest?
 // (like Option unit tests.)
 namespace trivially_relocatable {
 using T = TriviallyRelocatable;
-static_assert(std::is_move_constructible_v<Array<T, 2>>, "");
-static_assert(std::is_move_assignable_v<Array<T, 2>>, "");
-static_assert(std::is_trivially_destructible_v<Array<T, 2>>, "");
-static_assert(std::is_trivially_move_constructible_v<Array<T, 2>>, "");
-static_assert(std::is_trivially_move_assignable_v<Array<T, 2>>, "");
-static_assert(std::is_nothrow_swappable_v<Array<T, 2>>, "");
-static_assert(std::is_trivially_copy_constructible_v<Array<T, 2>>, "");
-static_assert(std::is_trivially_copy_assignable_v<Array<T, 2>>, "");
-static_assert(!std::is_constructible_v<Array<T, 2>, T&&>, "");
-static_assert(!std::is_assignable_v<Array<T, 2>, T&&>, "");
-static_assert(!std::is_constructible_v<Array<T, 2>, const T&>, "");
-static_assert(!std::is_assignable_v<Array<T, 2>, const T&>, "");
-static_assert(!std::is_constructible_v<Array<T, 2>, T>, "");
-static_assert(!std::is_assignable_v<Array<T, 2>, T>, "");
-static_assert(std::is_nothrow_destructible_v<Array<T, 2>>, "");
-static_assert(relocate_one_by_memcpy<Array<T, 2>>, "");
-static_assert(relocate_array_by_memcpy<Array<T, 2>>, "");
+static_assert(std::is_move_constructible_v<Array<T, 2>>);
+static_assert(std::is_move_assignable_v<Array<T, 2>>);
+static_assert(std::is_trivially_destructible_v<Array<T, 2>>);
+static_assert(std::is_trivially_move_constructible_v<Array<T, 2>>);
+static_assert(std::is_trivially_move_assignable_v<Array<T, 2>>);
+static_assert(std::is_nothrow_swappable_v<Array<T, 2>>);
+static_assert(std::is_trivially_copy_constructible_v<Array<T, 2>>);
+static_assert(std::is_trivially_copy_assignable_v<Array<T, 2>>);
+static_assert(!std::is_constructible_v<Array<T, 2>, T&&>);
+static_assert(!std::is_assignable_v<Array<T, 2>, T&&>);
+static_assert(!std::is_constructible_v<Array<T, 2>, const T&>);
+static_assert(!std::is_assignable_v<Array<T, 2>, const T&>);
+static_assert(!std::is_constructible_v<Array<T, 2>, T>);
+static_assert(!std::is_assignable_v<Array<T, 2>, T>);
+static_assert(std::is_nothrow_destructible_v<Array<T, 2>>);
+static_assert(relocate_one_by_memcpy<Array<T, 2>>);
+static_assert(relocate_array_by_memcpy<Array<T, 2>>);
 }  // namespace trivially_relocatable
 
 struct NonAggregate {
@@ -64,18 +66,18 @@ struct NonAggregate {
 
 TEST(Array, WithDefault) {
   auto a = Array<int, 5>::with_default();
-  static_assert(sizeof(a) == sizeof(int[5]), "");
+  static_assert(sizeof(a) == sizeof(int[5]));
   for (size_t i = 0; i < 5; ++i) {
     EXPECT_EQ(a.get(i), 0);
   }
 
-  static_assert(sizeof(Array<int, 5>::with_default()) == sizeof(int[5]), "");
+  static_assert(sizeof(Array<int, 5>::with_default()) == sizeof(int[5]));
 }
 
 TEST(Array, Zero) {
   auto a = Array<int, 0>::with_default();
-  static_assert(sizeof(a) == 1, "");
-  static_assert(sizeof(Array<int, 0>::with_default()) == 1, "");
+  static_assert(sizeof(a) == 1);
+  static_assert(sizeof(Array<int, 0>::with_default()) == 1);
 }
 
 TEST(Array, WithUninitialized) {
@@ -86,7 +88,7 @@ TEST(Array, WithUninitialized) {
 
 TEST(Array, WithInitializer) {
   auto a = Array<int, 5>::with_initializer([i = 1]() mutable { return i++; });
-  static_assert(sizeof(a) == sizeof(int[5]), "");
+  static_assert(sizeof(a) == sizeof(int[5]));
   for (size_t i = 0; i < 5; ++i) {
     EXPECT_EQ(a.get(i), i + 1);
   }
@@ -101,14 +103,14 @@ TEST(Array, WithInitializer) {
                 "");
   auto b = Array<NotTriviallyDefaultConstructible, 5>::with_initializer(
       [i = 1]() mutable -> NotTriviallyDefaultConstructible { return {i++}; });
-  static_assert(sizeof(b) == sizeof(NotTriviallyDefaultConstructible[5]), "");
+  static_assert(sizeof(b) == sizeof(NotTriviallyDefaultConstructible[5]));
   for (size_t i = 0; i < 5; ++i) {
     EXPECT_EQ(b.get(i).i, i + 1);
   }
 
   auto lvalue = [i = 1]() mutable { return i++; };
   auto c = Array<int, 5>::with_initializer(lvalue);
-  static_assert(sizeof(c) == sizeof(int[5]), "");
+  static_assert(sizeof(c) == sizeof(int[5]));
   for (size_t i = 0; i < 5; ++i) {
     EXPECT_EQ(c.get(i), i + 1);
   }
@@ -120,12 +122,31 @@ TEST(Array, WithInitializer) {
 
 TEST(Array, WithValue) {
   auto a = Array<int, 5>::with_value(3);
-  static_assert(sizeof(a) == sizeof(int[5]), "");
+  static_assert(sizeof(a) == sizeof(int[5]));
   for (size_t i = 0; i < 5; ++i) {
     EXPECT_EQ(a.get(i), 3);
   }
 }
 
+TEST(Array, WithValues) {
+  {
+    auto a = Array<int, 5>::with_values(3, 4, 5, 6, 7);
+    static_assert(sizeof(a) == sizeof(int[5]));
+    for (size_t i = 0; i < 5; ++i) {
+      EXPECT_EQ(a.get(i), 3 + i);
+    }
+  }
+  {
+    auto a = Array<u8, 5>::with_values(sus::into(3), sus::into(4), sus::into(5),
+                                       sus::into(6), sus::into(7));
+    static_assert(sizeof(a) == sizeof(u8[5]));
+    for (auto i = 0_u8; i < 5_u8; i += 1_u8) {
+      EXPECT_EQ(a.get(/* TODO: usize */ usize::from(i).primitive_value),
+                3_u8 + i);
+    }
+  }
+}
+
 TEST(Array, Get) {
   {
     constexpr auto r = []() constexpr {
@@ -161,7 +182,6 @@ TEST(Array, GetMut) {
   }
 }
 
-
 TEST(Array, AsPtr) {
   auto a = Array<int, 5>::with_initializer([i = 0]() mutable { return ++i; });
   auto r = a.as_ptr();