add beman::has_constexpr_support

README.md

@@ -82,6 +82,18 @@ static_assert(check_5());
 
 ```
 
+### Note on constexpr support
+
+Since `constexpr` requirements are actively changing,
+you can use `beman::has_constexpr_support` to detect if our implementation
+provide constexpr support for a specific specialization of `inplace_vector`.
+
+Note this is not part of the standard Library and should not be relied on once
+`constexpr` requirement stabilize.
+
+Example Usage:
+`static_assert(beman::has_constexpr_support<beman::inplace_vector<int, 5>>)`.
+
 ## How to Build
 
 ### Compiler support

include/beman/inplace_vector/inplace_vector.hpp

@@ -306,6 +306,9 @@ concept container_compatible_range =
     std::ranges::input_range<Rng> &&
     std::convertible_to<std::ranges::range_reference_t<Rng>, T>;
 
+template <typename T, std::size_t N>
+concept satify_constexpr = N == 0 || std::is_trivial_v<T>;
+
 } // namespace beman::details::inplace_vector
 
 // Types implementing the `inplace_vector`'s storage
@@ -425,13 +428,18 @@ template <class T, size_t N> struct non_trivial {
 // Selects the vector storage.
 template <class T, size_t N>
 using storage_for = std::conditional_t<
-    N == 0, zero_sized<T>,
-    std::conditional_t<std::is_trivial_v<T>, trivial<T, N>, non_trivial<T, N>>>;
+    !satify_constexpr<T, N>, non_trivial<T, N>,
+    std::conditional_t<N == 0, zero_sized<T>, trivial<T, N>>>;
 
 } // namespace beman::details::inplace_vector::storage
 
 namespace beman {
 
+template <typename IV>
+concept has_constexpr_support =
+    details::inplace_vector::satify_constexpr<typename IV::value_type,
+                                              IV::capacity()>;
+
 /// Dynamically-resizable fixed-N vector with inplace storage.
 template <class T, size_t N>
 struct inplace_vector

tests/beman/inplace_vector/constexpr.test.cpp

@@ -2,6 +2,10 @@
 #include <beman/inplace_vector/inplace_vector.hpp>
 #include <type_traits>
 
+// used for testing beman::has_constexpr_support
+#include <memory>
+#include <string>
+
 /**
  * These tests are only meant to test that suitable constexpr functions compiles
  * in a constant evaluation environment.
@@ -25,6 +29,18 @@ struct Some {
 };
 static_assert(std::is_trivial_v<Some>);
 
+using beman::has_constexpr_support;
+using beman::inplace_vector;
+
+static_assert(has_constexpr_support<inplace_vector<int, 50>>);
+static_assert(has_constexpr_support<inplace_vector<Some, 50>>);
+
+static_assert(has_constexpr_support<inplace_vector<std::string, 0>>);
+static_assert(!has_constexpr_support<inplace_vector<std::string, 50>>);
+
+static_assert(has_constexpr_support<inplace_vector<std::unique_ptr<int>, 0>>);
+static_assert(!has_constexpr_support<inplace_vector<std::unique_ptr<int>, 50>>);
+
 #define TEST(NAME)                                                             \
   static_assert(std::invoke([]() {                                             \
                   NAME<beman::inplace_vector<int, 20>>();                      \
@@ -268,6 +284,9 @@ struct Complex {
 };
 static_assert(!std::is_trivially_default_constructible_v<Complex>);
 
+static_assert(has_constexpr_support<inplace_vector<Complex, 0>>);
+static_assert(!has_constexpr_support<inplace_vector<Complex, 50>>);
+
 #define TEST_EMPTY(NAME)                                                       \
   static_assert(std::invoke([]() {                                             \
                   NAME<Complex>();                                             \