Add freestanding build support

Author: 20162026

include/beman/inplace_vector/inplace_vector.hpp

@@ -271,6 +271,13 @@ Software.
 // Artifact from previous implementation, can be used as hints for optimizer
 #define IV_EXPECT(EXPR)
 
+#if (!defined(__EXCEPTIONS) && !defined(_CPPUNWIND)) ||                        \
+    __STDC_HOSTED__ == 0 || BEMAN_IV_FREESTANDING_FORCE_TEST
+#define BEMAN_IV_FREESTANDING_DELETE(impl) = delete
+#else
+#define BEMAN_IV_FREESTANDING_DELETE(impl) impl
+#endif
+
 // beman::from_range_t
 namespace beman {
 struct from_range_t {};
@@ -531,10 +538,11 @@ struct inplace_vector
   static constexpr size_type capacity() noexcept { return N; }
   // constexpr void resize(size_type sz);
   // constexpr void resize(size_type sz, const T& c);
-  constexpr void reserve(size_type n) {
+  constexpr void reserve(size_type n) BEMAN_IV_FREESTANDING_DELETE({
     if (n > N) [[unlikely]]
       throw std::bad_alloc();
-  }
+  });
+
   constexpr void shrink_to_fit() {}
 
   // element access
@@ -663,23 +671,23 @@ struct inplace_vector
   template <class... Args>
   constexpr T &emplace_back(Args &&...args)
     requires(std::constructible_from<T, Args...>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     if (!try_emplace_back(std::forward<Args>(args)...)) [[unlikely]]
       throw std::bad_alloc();
     return back();
-  }
+  });
   constexpr T &push_back(const T &x)
     requires(std::constructible_from<T, const T &>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     emplace_back(x);
     return back();
-  }
+  });
   constexpr T &push_back(T &&x)
     requires(std::constructible_from<T, T &&>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     emplace_back(std::forward<T &&>(x));
     return back();
-  }
+  });
 
   constexpr T *try_push_back(const T &x)
     requires(std::constructible_from<T, const T &>)
@@ -706,7 +714,7 @@ struct inplace_vector
   template <details::inplace_vector::container_compatible_range<T> R>
   constexpr void append_range(R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     if constexpr (std::ranges::sized_range<R>) {
       if (size() + std::ranges::size(rg) > capacity()) [[unlikely]]
         throw std::bad_alloc();
@@ -716,26 +724,26 @@ struct inplace_vector
         throw std::bad_alloc();
       emplace_back(std::forward<decltype(e)>(e));
     }
-  }
+  });
 
   template <class... Args>
   constexpr iterator emplace(const_iterator position, Args &&...args)
     requires(std::constructible_from<T, Args...> && std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     assert_iterator_in_range(position);
     auto b = end();
     emplace_back(std::forward<Args>(args)...);
     auto pos = begin() + (position - begin());
     std::rotate(pos, b, end());
     return pos;
-  }
+  });
 
   template <class InputIterator>
   constexpr iterator insert(const_iterator position, InputIterator first,
                             InputIterator last)
     requires(std::constructible_from<T, std::iter_reference_t<InputIterator>> &&
              std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     assert_iterator_in_range(position);
     if constexpr (std::random_access_iterator<InputIterator>) {
       if (size() + static_cast<size_type>(std::distance(first, last)) >
@@ -748,85 +756,73 @@ struct inplace_vector
     auto pos = begin() + (position - begin());
     std::rotate(pos, b, end());
     return pos;
-  }
+  });
 
   template <details::inplace_vector::container_compatible_range<T> R>
   constexpr iterator insert_range(const_iterator position, R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>> &&
              std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     return insert(position, std::begin(rg), std::end(rg));
-  }
+  });
 
   constexpr iterator insert(const_iterator position,
                             std::initializer_list<T> il)
     requires(std::constructible_from<
                  T, std::ranges::range_reference_t<std::initializer_list<T>>> &&
              std::movable<T>)
-  {
-    return insert_range(position, il);
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ return insert_range(position, il); });
 
   constexpr iterator insert(const_iterator position, size_type n, const T &x)
     requires(std::constructible_from<T, const T &> && std::copyable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     assert_iterator_in_range(position);
     auto b = end();
     for (size_type i = 0; i < n; ++i)
       emplace_back(x);
     auto pos = begin() + (position - begin());
     std::rotate(pos, b, end());
     return pos;
-  }
+  });
 
   constexpr iterator insert(const_iterator position, const T &x)
     requires(std::constructible_from<T, const T &> && std::copyable<T>)
-  {
-    return insert(position, 1, x);
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ return insert(position, 1, x); });
 
   constexpr iterator insert(const_iterator position, T &&x)
     requires(std::constructible_from<T, T &&> && std::movable<T>)
-  {
-    return emplace(position, std::move(x));
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ return emplace(position, std::move(x)); });
 
   constexpr inplace_vector(std::initializer_list<T> il)
     requires(std::constructible_from<
                  T, std::ranges::range_reference_t<std::initializer_list<T>>> &&
              std::movable<T>)
-  {
-    insert(begin(), il);
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ insert(begin(), il); });
 
   constexpr inplace_vector(size_type n, const T &value)
     requires(std::constructible_from<T, const T &> && std::copyable<T>)
-  {
-    insert(begin(), n, value);
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ insert(begin(), n, value); });
 
   constexpr explicit inplace_vector(size_type n)
     requires(std::constructible_from<T, T &&> && std::default_initializable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     for (size_type i = 0; i < n; ++i)
       emplace_back(T{});
-  }
+  });
 
   template <class InputIterator> // BUGBUG: why not std::ranges::input_iterator?
   constexpr inplace_vector(InputIterator first, InputIterator last)
     requires(std::constructible_from<T, std::iter_reference_t<InputIterator>> &&
              std::movable<T>)
-  {
-    insert(begin(), first, last);
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ insert(begin(), first, last); });
 
   template <details::inplace_vector::container_compatible_range<T> R>
   constexpr inplace_vector(beman::from_range_t, R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>> &&
              std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     insert_range(begin(), std::forward<R &&>(rg));
-  }
+  });
 
   constexpr iterator erase(const_iterator first, const_iterator last)
     requires(std::movable<T>)
@@ -853,7 +849,7 @@ struct inplace_vector
 
   constexpr void resize(size_type sz, const T &c)
     requires(std::constructible_from<T, const T &> && std::copyable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     if (sz == size())
       return;
     else if (sz > N) [[unlikely]]
@@ -864,10 +860,10 @@ struct inplace_vector
       unsafe_destroy(begin() + sz, end());
       unsafe_set_size(sz);
     }
-  }
+  });
   constexpr void resize(size_type sz)
     requires(std::constructible_from<T, T &&> && std::default_initializable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     if (sz == size())
       return;
     else if (sz > N) [[unlikely]]
@@ -879,18 +875,19 @@ struct inplace_vector
       unsafe_destroy(begin() + sz, end());
       unsafe_set_size(sz);
     }
-  }
+  });
 
-  constexpr reference at(size_type pos) {
+  constexpr reference at(size_type pos) BEMAN_IV_FREESTANDING_DELETE({
     if (pos >= size()) [[unlikely]]
       throw std::out_of_range("inplace_vector::at");
     return details::inplace_vector::index(*this, pos);
-  }
-  constexpr const_reference at(size_type pos) const {
-    if (pos >= size()) [[unlikely]]
-      throw std::out_of_range("inplace_vector::at");
-    return details::inplace_vector::index(*this, pos);
-  }
+  });
+  constexpr const_reference at(size_type pos) const
+      BEMAN_IV_FREESTANDING_DELETE({
+        if (pos >= size()) [[unlikely]]
+          throw std::out_of_range("inplace_vector::at");
+        return details::inplace_vector::index(*this, pos);
+      });
 
   constexpr void pop_back() {
     IV_EXPECT(size() > 0 && "pop_back from empty inplace_vector!");
@@ -975,31 +972,29 @@ struct inplace_vector
   constexpr void assign(InputIterator first, InputIterator last)
     requires(std::constructible_from<T, std::iter_reference_t<InputIterator>> &&
              std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     clear();
     insert(begin(), first, last);
-  }
+  });
   template <details::inplace_vector::container_compatible_range<T> R>
   constexpr void assign_range(R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>> &&
              std::movable<T>)
-  {
-    assign(std::begin(rg), std::end(rg));
-  }
+  BEMAN_IV_FREESTANDING_DELETE({ assign(std::begin(rg), std::end(rg)); });
   constexpr void assign(size_type n, const T &u)
     requires(std::constructible_from<T, const T &> && std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     clear();
     insert(begin(), n, u);
-  }
+  });
   constexpr void assign(std::initializer_list<T> il)
     requires(std::constructible_from<
                  T, std::ranges::range_reference_t<std::initializer_list<T>>> &&
              std::movable<T>)
-  {
+  BEMAN_IV_FREESTANDING_DELETE({
     clear();
     insert_range(begin(), il);
-  }
+  });
 
   constexpr friend int /*synth-three-way-result<T>*/
   operator<=>(const inplace_vector & x, const inplace_vector & y) {
@@ -1044,3 +1039,4 @@ constexpr std::size_t erase_if(inplace_vector<T, N> &c, Predicate pred) {
 } // namespace beman
 
 #undef IV_EXPECT
+#undef BEMAN_IV_FREESTANDING_DELETE

tests/beman/inplace_vector/CMakeLists.txt

@@ -40,6 +40,12 @@ add_gtest(triviality)
 add_gtest(constructors)
 add_gtest(size_n_data)
 add_gtest(erasure)
+add_gtest(freestanding)
+
+set_source_files_properties(
+    freestanding.test.cpp
+    PROPERTIES COMPILE_FLAGS "-DBEMAN_IV_FREESTANDING_FORCE_TEST"
+)
 
 # constexpr test
 add_executable(beman.inplace_vector.tests.constexpr constexpr.test.cpp)

tests/beman/inplace_vector/freestanding.test.cpp

@@ -0,0 +1,29 @@
+#include <gtest/gtest.h>
+#include <type_traits>
+
+#include "gtest_setup.hpp"
+
+namespace {
+
+template <typename Param> class Freestanding : public IVBasicTest<Param> {};
+TYPED_TEST_SUITE(Freestanding, IVAllTypes);
+
+TYPED_TEST(Freestanding, alltypes) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  using size_type = IV::size_type;
+
+  IV vec;
+  for (size_type i = 0; i < IV::capacity(); ++i) {
+    EXPECT_NE(vec.try_push_back(T{}), nullptr);
+  }
+  EXPECT_EQ(vec.try_push_back(T{}), nullptr);
+
+  EXPECT_EQ(vec.size(), IV::capacity());
+
+  vec.clear();
+  EXPECT_EQ(vec.size(), 0);
+
+}
+} // namespace