noexceptions

CMakeLists.txt

@@ -27,6 +27,18 @@ option(
     ${PROJECT_IS_TOP_LEVEL}
 )
 
+option(
+    BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS
+    "Disable exceptions by replacing throw calls with abort. Default: OFF. Values: { ON, OFF }."
+    OFF
+)
+
+configure_file(
+    "${PROJECT_SOURCE_DIR}/include/beman/inplace_vector/config.hpp.in"
+    "${PROJECT_BINARY_DIR}/include/beman/inplace_vector/config.hpp"
+    @ONLY
+)
+
 include(FetchContent)
 include(GNUInstallDirs)
 
@@ -38,6 +50,7 @@ target_include_directories(
     beman.inplace_vector
     INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
         $<INSTALL_INTERFACE:include>
 )
 

include/beman/inplace_vector/config.hpp.in

@@ -0,0 +1,6 @@
+#ifndef BEMAN_INPLACE_VECTOR_CONFIG_HPP
+#define BEMAN_INPLACE_VECTOR_CONFIG_HPP
+
+#cmakedefine01 BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()
+
+#endif

include/beman/inplace_vector/inplace_vector.hpp

@@ -2,6 +2,7 @@
 
 #ifndef BEMAN_INPLACE_VECTOR_INPLACE_VECTOR_HPP
 #define BEMAN_INPLACE_VECTOR_INPLACE_VECTOR_HPP
+#include <beman/inplace_vector/config.hpp>
 
 #include <algorithm> // for rotate...
 #include <array>
@@ -10,19 +11,28 @@
 #include <cstddef>    // for size_t
 #include <cstdint>    // for fixed-width integer types
 #include <cstdio>     // for assertion diagnostics
-#include <cstdlib>    // for abort
 #include <functional> // for less and equal_to
 #include <iterator>   // for reverse_iterator and iterator traits
 #include <limits>     // for numeric_limits
 #include <memory>     // for destroy
 #include <new>        // for operator new
 #include <ranges>
-#include <stdexcept>   // for length_error
 #include <type_traits> // for aligned_storage and all meta-functions
 
 // Artifact from previous implementation, can be used as hints for optimizer
 #define IV_EXPECT(EXPR)
 
+#ifndef BEMAN_IV_THROW_OR_ABORT
+#if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L ||                \
+    BEMAN_INPLACE_VECTOR_NO_EXCEPTIONS()
+#include <cstdlib> // for abort
+#define BEMAN_IV_THROW_OR_ABORT(x) abort()
+#else
+#include <stdexcept> // for length_error
+#define BEMAN_IV_THROW_OR_ABORT(x) throw x
+#endif
+#endif
+
 // beman::from_range_t
 namespace beman {
 struct from_range_t {};
@@ -260,8 +270,9 @@ struct inplace_vector
   static constexpr size_type max_size() noexcept { return N; }
   static constexpr size_type capacity() noexcept { return N; }
   constexpr void reserve(size_type n) {
-    if (n > N) [[unlikely]]
-      throw std::bad_alloc();
+    if (n > N) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+    }
   }
   constexpr void shrink_to_fit() {}
 
@@ -351,8 +362,9 @@ struct inplace_vector
   constexpr T &emplace_back(Args &&...args)
     requires(std::constructible_from<T, Args...>)
   {
-    if (!try_emplace_back(std::forward<Args>(args)...)) [[unlikely]]
-      throw std::bad_alloc();
+    if (!try_emplace_back(std::forward<Args>(args)...)) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+    }
     return back();
   }
   constexpr T &push_back(const T &x)
@@ -395,12 +407,14 @@ struct inplace_vector
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>>)
   {
     if constexpr (std::ranges::sized_range<R>) {
-      if (size() + std::ranges::size(rg) > capacity()) [[unlikely]]
-        throw std::bad_alloc();
+      if (size() + std::ranges::size(rg) > capacity()) [[unlikely]] {
+        BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+      }
     }
     for (auto &&e : rg) {
-      if (size() == capacity()) [[unlikely]]
-        throw std::bad_alloc();
+      if (size() == capacity()) [[unlikely]] {
+        BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+      }
       emplace_back(std::forward<decltype(e)>(e));
     }
   }
@@ -438,8 +452,9 @@ struct inplace_vector
     assert_iterator_in_range(position);
     if constexpr (std::random_access_iterator<InputIterator>) {
       if (size() + static_cast<size_type>(std::distance(first, last)) >
-          capacity()) [[unlikely]]
-        throw std::bad_alloc{};
+          capacity()) [[unlikely]] {
+        BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+      }
     }
     auto b = end();
     for (; first != last; ++first)
@@ -555,9 +570,9 @@ struct inplace_vector
   {
     if (sz == size())
       return;
-    else if (sz > N) [[unlikely]]
-      throw std::bad_alloc{};
-    else if (sz > size())
+    else if (sz > N) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+    } else if (sz > size())
       insert(end(), sz - size(), c);
     else {
       unsafe_destroy(begin() + sz, end());
@@ -569,25 +584,27 @@ struct inplace_vector
   {
     if (sz == size())
       return;
-    else if (sz > N) [[unlikely]]
-      throw std::bad_alloc{};
-    else if (sz > size())
+    else if (sz > N) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(std::bad_alloc());
+    } else if (sz > size()) {
       while (size() != sz)
         emplace_back(T{});
-    else {
+    } else {
       unsafe_destroy(begin() + sz, end());
       unsafe_set_size(sz);
     }
   }
 
   constexpr reference at(size_type pos) {
-    if (pos >= size()) [[unlikely]]
-      throw std::out_of_range("inplace_vector::at");
+    if (pos >= size()) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(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");
+    if (pos >= size()) [[unlikely]] {
+      BEMAN_IV_THROW_OR_ABORT(std::out_of_range("inplace_vector::at"));
+    }
     return details::inplace_vector::index(*this, pos);
   }
 
@@ -606,7 +623,7 @@ struct inplace_vector
              std::copyable<T>)
   {
     for (auto &&e : x)
-      emplace_back(e);
+      unchecked_emplace_back(e);
   }
 
   constexpr inplace_vector(inplace_vector &&x)
@@ -618,7 +635,7 @@ struct inplace_vector
              std::movable<T>)
   {
     for (auto &&e : x)
-      emplace_back(std::move(e));
+      unchecked_emplace_back(std::move(e));
   }
 
   constexpr inplace_vector &operator=(const inplace_vector &x)
@@ -636,7 +653,7 @@ struct inplace_vector
   {
     clear();
     for (auto &&e : x)
-      emplace_back(e);
+      unchecked_emplace_back(e);
     return *this;
   }
 
@@ -655,7 +672,7 @@ struct inplace_vector
   {
     clear();
     for (auto &&e : x)
-      emplace_back(std::move(e));
+      unchecked_emplace_back(std::move(e));
     return *this;
   }
 

tests/beman/inplace_vector/CMakeLists.txt

@@ -43,6 +43,17 @@ add_gtest(size_n_data)
 add_gtest(erasure)
 add_gtest(modifiers)
 
+if(
+    CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
+    OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
+)
+    add_gtest(noexceptions)
+    target_compile_options(
+        beman.inplace_vector.tests.noexceptions
+        PRIVATE -fno-exceptions
+    )
+endif()
+
 # constexpr test
 add_executable(beman.inplace_vector.tests.constexpr constexpr.test.cpp)
 target_link_libraries(

tests/beman/inplace_vector/noexceptions.test.cpp

@@ -0,0 +1,158 @@
+#include <array>
+
+#include "gtest_setup.hpp"
+
+namespace {
+
+// clang-format off
+using exceptionTestTypes = ::testing::Types<
+    TestParam<Trivial, 0>, TestParam<Trivial, 42>,
+    TestParam<NonTrivial, 0>, TestParam<NonTrivial, 42>>;
+// clang-format on
+
+template <typename Param> class NoExceptions : public IVBasicTest<Param> {};
+TYPED_TEST_SUITE(NoExceptions, exceptionTestTypes);
+
+TYPED_TEST(NoExceptions, NonThrowing) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+
+  const auto reference = this->unique();
+
+  IV device;
+
+  device.assign(reference.begin(), reference.end());
+  EXPECT_EQ(device, reference);
+
+  EXPECT_EQ(device.try_emplace_back(T{}), nullptr);
+  EXPECT_EQ(device.try_push_back(T{}), nullptr);
+  auto range = std::array<T, 1>{};
+  EXPECT_EQ(device.try_append_range(range), range.begin());
+
+  IV sanitycheck = this->unique();
+  EXPECT_EQ(sanitycheck.size(), IV::capacity());
+}
+
+TYPED_TEST(NoExceptions, emplace_back) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        device.emplace_back(T{});
+      },
+      ".*");
+}
+
+TYPED_TEST(NoExceptions, resize) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        device.resize(IV::capacity() + 1);
+      },
+      ".*");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        device.resize(IV::capacity() + 1, T{});
+      },
+      ".*");
+}
+
+TYPED_TEST(NoExceptions, reserve) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        device.reserve(IV::capacity() + 1);
+      },
+      ".*");
+}
+
+TYPED_TEST(NoExceptions, append_range) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  EXPECT_DEATH(
+      {
+        IV device{};
+        device.append_range(std::array<T, IV::capacity() + 1>{});
+      },
+      ".*");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        device.append_range(std::array<T, 1>{});
+      },
+      ".*");
+
+  // TODO consider adding test for append_range of unsized range
+}
+
+TYPED_TEST(NoExceptions, insert) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  if constexpr (IV::capacity() > 0) {
+    EXPECT_DEATH(
+        {
+          IV device = this->unique();
+          // test macro fails to compile if we use std::array<T, N> without
+          // parenthesis ()
+          auto range = (std::array<T, IV::capacity()>{});
+          device.insert(device.end(), range.begin(), range.end());
+        },
+        ".*");
+  }
+
+  EXPECT_DEATH(
+      {
+        IV device{};
+        // test macro fails to compile if we use std::array<T, N> without
+        // parenthesis ()
+        auto range = (std::array<T, IV::capacity() + 1>{});
+        device.insert(device.end(), range.begin(), range.end());
+      },
+      ".*");
+}
+
+TYPED_TEST(NoExceptions, at) {
+
+  using IV = TestFixture::IV;
+  using T = TestFixture::T;
+  GTEST_FLAG_SET(death_test_style, "fast");
+
+  EXPECT_DEATH(
+      {
+        IV device = this->unique();
+        auto e = device.at(IV::capacity());
+      },
+      ".*");
+
+  EXPECT_DEATH(
+      {
+        IV device;
+        const auto e = device.at(IV::capacity());
+      },
+      ".*");
+}
+} // namespace