remove inplace_vector_array_type and add const tests

Author: wusatosi

include/beman/inplace_vector/inplace_vector.hpp

@@ -56,17 +56,14 @@ using inplace_vector_internal_size_type =
           If<Capacity <= std::numeric_limits<uint32_t>::max(), uint32_t,
              uint64_t>>>;
 
-template <typename T, std::size_t Capacity>
-using inplace_vector_array_type =
-    If<!std::is_const_v<T>, std::array<T, Capacity>,
-       const std::array<std::remove_const_t<T>, Capacity>>;
-
 // array based storage is used so that we can satisfy constexpr requirement
 //
 // Selecting this storage type implies: std::is_trivial_v<T> or Capacity = 0
 template <typename T, std::size_t Capacity>
 struct inplace_vector_type_based_storage {
-  inplace_vector_array_type<T, Capacity> elems{};
+  using array_type = If<!std::is_const_v<T>, std::array<T, Capacity>,
+                        const std::array<std::remove_const_t<T>, Capacity>>;
+  array_type elems{};
 
   constexpr T *begin() { return elems.data(); }
   constexpr const T *begin() const { return elems.data(); }
@@ -78,11 +75,11 @@ struct inplace_vector_type_based_storage {
 // Selecting this storage type implies: !std::is_trivial_v<T> and Capacity != 0
 template <typename T, std::size_t Capacity>
 struct inplace_vector_bytes_based_storage {
-  alignas(T) inplace_vector_array_type<std::byte, Capacity * sizeof(T)> elems;
+  alignas(T) std::array<std::byte, Capacity * sizeof(T)> elems;
 
-  T *begin() { return std::launder(reinterpret_cast<const T *>(elems)); }
+  T *begin() { return std::launder(reinterpret_cast<const T *>(elems.data())); }
   const T *begin() const {
-    return std::launder(reinterpret_cast<const T *>(elems));
+    return std::launder(reinterpret_cast<const T *>(elems.data()));
   }
 };
 

tests/beman/inplace_vector/inplace_vector.test.cpp

@@ -1,8 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <beman/inplace_vector/inplace_vector.hpp>
+#include <type_traits>
 
 using namespace beman::inplace_vector;
 
+struct NonTrivial {
+  int z = 5;
+
+  bool operator==(NonTrivial const &other) { return this->z == other.z; }
+};
+static_assert(!std::is_trivial_v<NonTrivial>);
+
 template <typename T> constexpr void test() {
   using vec = inplace_vector<T, 42>;
   vec range{T(1), T(1337), T(42), T(12), T(0), T(-1)};
@@ -82,8 +90,19 @@ void test_exceptions() {
     }
   }
 }
+
+template <typename T> void test_const() {
+  inplace_vector<const T, 20> vec;
+  vec.push_back({50});
+  const T &first = vec.front();
+  assert(first == T{50});
+}
+
 int main() {
   test<int>();
   test_exceptions();
+
+  test_const<int>();
+  test_const<NonTrivial>();
   return 0;
 }