Rename namespace for consistency

Author: 20162026

README.md

@@ -49,7 +49,7 @@ Contributions are welcome.
 
 #include <beman/inplace_vector/inplace_vector.hpp>
 
-using namespace beman;
+using namespace beman::inplace_vector;
 
 /**
  * Generates fibonacci sequence using inplace_vector.
@@ -93,21 +93,21 @@ 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>>)`.
+`static_assert(beman::has_constexpr_support<beman::inplace_vector::inplace_vector<int, 5>>)`.
 
 ### Freestanding
 
-`beman::freestanding::inplace_vector` implements a minimal freestanding version of the specification,
+`beman::inplace_vector::freestanding::inplace_vector` implements a minimal freestanding version of the specification,
 which marks all potentially throwing functions as `= deleted`.
 This is useful for platforms without exception support, as it will generate a compile-time error
 instead of a potential runtime error when trying to use a throwing function.
 
 ``` C++
-beman::inplace_vector<int, 1> iv;
+beman::inplace_vector::inplace_vector<int, 1> iv;
 iv.resize(0); // OK
 iv.resize(10); // will throw or abort
 
-beman::freestanding::inplace_vector<int, 1> fs_iv;
+beman::inplace_vector::freestanding::inplace_vector<int, 1> fs_iv;
 fs_iv.resize(0); // will generate a compile-time error
 fs_iv.resize(10); // will generate a compile-time error
 ```

examples/fibonacci.cpp

@@ -4,7 +4,7 @@
 
 #include <beman/inplace_vector/inplace_vector.hpp>
 
-using namespace beman;
+using namespace beman::inplace_vector;
 
 /**
  * Generates fibonacci sequence using inplace_vector.

include/beman/inplace_vector/inplace_vector.hpp

@@ -44,7 +44,7 @@ inline constexpr from_range_t from_range;
 }; // namespace beman
 
 // Private utilities
-namespace beman::details::inplace_vector {
+namespace beman::inplace_vector::details {
 
 // clang-format off
 // Smallest unsigned integer that can represent values in [0, N].
@@ -80,10 +80,7 @@ concept lessthan_comparable = requires(const T &a, const T &b) {
   { a < b } -> std::convertible_to<bool>;
 };
 
-} // namespace beman::details::inplace_vector
-
 // Types implementing the `inplace_vector`'s storage
-namespace beman::details::inplace_vector {
 namespace storage {
 
 // Storage for zero elements.
@@ -271,22 +268,20 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
   // element access
 
   constexpr reference operator[](size_type n) {
-    return details::inplace_vector::index(*this, n);
+    return details::index(*this, n);
   }
   constexpr const_reference operator[](size_type n) const {
-    return details::inplace_vector::index(*this, n);
-  }
-  constexpr reference front() {
-    return details::inplace_vector::index(*this, size_type(0));
+    return details::index(*this, n);
   }
+  constexpr reference front() { return details::index(*this, size_type(0)); }
   constexpr const_reference front() const {
-    return details::inplace_vector::index(*this, size_type(0));
+    return details::index(*this, size_type(0));
   }
   constexpr reference back() {
-    return details::inplace_vector::index(*this, size() - size_type(1));
+    return details::index(*this, size() - size_type(1));
   }
   constexpr const_reference back() const {
-    return details::inplace_vector::index(*this, size() - size_type(1));
+    return details::index(*this, size() - size_type(1));
   }
 
   // [containers.sequences.inplace_vector.data], data access
@@ -361,7 +356,7 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
     return unchecked_emplace_back(std::forward<T &&>(x));
   }
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::container_compatible_range<T> R>
   constexpr std::ranges::borrowed_iterator_t<R> try_append_range(R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>>)
   {
@@ -428,7 +423,7 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
 
   constexpr friend auto operator<=>(const inplace_vector_base &x,
                                     const inplace_vector_base &y)
-    requires(beman::details::inplace_vector::lessthan_comparable<T>)
+    requires(details::lessthan_comparable<T>)
   {
     if constexpr (std::three_way_comparable<T>) {
       return std::lexicographical_compare_three_way(x.begin(), x.end(),
@@ -514,19 +509,17 @@ struct inplace_vector_base : private storage::storage_for<T, N> {
   }
 };
 
-} // namespace beman::details::inplace_vector
+} // namespace beman::inplace_vector::details
 
-namespace beman {
+namespace beman::inplace_vector {
 
 template <typename IV>
 concept has_constexpr_support =
-    details::inplace_vector::satify_constexpr<typename IV::value_type,
-                                              IV::capacity()>;
+    details::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
-    : public details::inplace_vector::inplace_vector_base<T, N> {
+struct inplace_vector : public details::inplace_vector_base<T, N> {
   using value_type = T;
   using pointer = T *;
   using const_pointer = const T *;
@@ -563,7 +556,7 @@ struct inplace_vector
     return this->back();
   }
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::container_compatible_range<T> R>
   constexpr void append_range(R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>>)
   {
@@ -614,7 +607,7 @@ struct inplace_vector
     return pos;
   }
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -672,7 +665,7 @@ struct inplace_vector
     this->clear();
     insert(this->begin(), first, last);
   }
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -738,13 +731,13 @@ struct inplace_vector
     if (pos >= this->size()) [[unlikely]] {
       BEMAN_IV_THROW_OR_ABORT(std::out_of_range("inplace_vector::at"));
     }
-    return details::inplace_vector::index(*this, pos);
+    return details::index(*this, pos);
   }
   constexpr const_reference at(size_type pos) const {
     if (pos >= this->size()) [[unlikely]] {
       BEMAN_IV_THROW_OR_ABORT(std::out_of_range("inplace_vector::at"));
     }
-    return details::inplace_vector::index(*this, pos);
+    return details::index(*this, pos);
   }
 
   // [containers.sequences.inplace_vector.cons], construct/copy/destroy
@@ -780,7 +773,7 @@ struct inplace_vector
     insert(this->begin(), first, last);
   }
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -791,8 +784,7 @@ struct inplace_vector
 
 namespace freestanding {
 template <class T, size_t N>
-struct inplace_vector
-    : public details::inplace_vector::inplace_vector_base<T, N> {
+struct inplace_vector : public details::inplace_vector_base<T, N> {
   using value_type = T;
   using pointer = T *;
   using const_pointer = const T *;
@@ -818,7 +810,7 @@ struct inplace_vector
     requires(std::constructible_from<T, T &&>)
   = delete;
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::container_compatible_range<T> R>
   constexpr void append_range(R &&rg)
     requires(std::constructible_from<T, std::ranges::range_reference_t<R>>)
   = delete;
@@ -835,7 +827,7 @@ struct inplace_vector
              std::movable<T>)
   = delete;
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -871,7 +863,7 @@ struct inplace_vector
     requires(std::constructible_from<T, std::iter_reference_t<InputIterator>> &&
              std::movable<T>)
   = delete;
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -925,7 +917,7 @@ struct inplace_vector
              std::movable<T>)
   = delete;
 
-  template <details::inplace_vector::container_compatible_range<T> R>
+  template <details::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>)
@@ -935,25 +927,24 @@ struct inplace_vector
 } // namespace freestanding
 
 template <typename T, std::size_t N, typename U = T>
-constexpr std::size_t
-erase(details::inplace_vector::inplace_vector_base<T, N> &c, const U &value) {
+constexpr std::size_t erase(details::inplace_vector_base<T, N> &c,
+                            const U &value) {
   auto it = std::remove(c.begin(), c.end(), value);
   auto r = std::distance(it, c.end());
   c.erase(it, c.end());
   return r;
 }
 
 template <typename T, std::size_t N, typename Predicate>
-constexpr std::size_t
-erase_if(details::inplace_vector::inplace_vector_base<T, N> &c,
-         Predicate pred) {
+constexpr std::size_t erase_if(details::inplace_vector_base<T, N> &c,
+                               Predicate pred) {
   auto it = std::remove_if(c.begin(), c.end(), pred);
   auto r = std::distance(it, c.end());
   c.erase(it, c.end());
   return r;
 }
 
-} // namespace beman
+} // namespace beman::inplace_vector
 
 #undef IV_EXPECT
 

tests/beman/inplace_vector/compare.test.cpp

@@ -4,7 +4,7 @@
 #include <cmath>
 #include <compare>
 
-using namespace beman;
+using namespace beman::inplace_vector;
 
 template <class T>
 concept has_threeway = requires(const T &t) {
@@ -13,7 +13,7 @@ concept has_threeway = requires(const T &t) {
 
 template <class T>
 concept lessthan_comparable =
-    beman::details::inplace_vector::lessthan_comparable<T>;
+    beman::inplace_vector::details::lessthan_comparable<T>;
 
 template <typename T> struct vec_list {
   T empty;

tests/beman/inplace_vector/constexpr.test.cpp

@@ -31,8 +31,8 @@ struct Some {
 };
 static_assert(std::is_trivial_v<Some>);
 
-using beman::has_constexpr_support;
-using beman::inplace_vector;
+using beman::inplace_vector::has_constexpr_support;
+using beman::inplace_vector::inplace_vector;
 
 static_assert(has_constexpr_support<inplace_vector<int, 50>>);
 static_assert(has_constexpr_support<inplace_vector<Some, 50>>);
@@ -45,8 +45,8 @@ 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>>();                      \
-                  NAME<beman::inplace_vector<Some, 20>>();                     \
+                  NAME<beman::inplace_vector::inplace_vector<int, 20>>();      \
+                  NAME<beman::inplace_vector::inplace_vector<Some, 20>>();     \
                   return true;                                                 \
                 }),                                                            \
                 "##NAME");
@@ -269,8 +269,8 @@ TEST(test_op_comp);
 
 template <typename IV> constexpr void test_erase() {
   IV v{0, 1, 2, 3, 3, 5};
-  (void)beman::erase(v, 3);
-  (void)beman::erase_if(v, [](auto v) { return v < 3; });
+  (void)beman::inplace_vector::erase(v, 3);
+  (void)beman::inplace_vector::erase_if(v, [](auto v) { return v < 3; });
 }
 TEST(test_erase)
 
@@ -298,7 +298,7 @@ static_assert(!has_constexpr_support<inplace_vector<Complex, 50>>);
 
 template <typename T> constexpr void speical_test_empty() {
   static_assert(!std::is_trivially_default_constructible_v<T>);
-  using IV = beman::inplace_vector<T, 0>;
+  using IV = beman::inplace_vector::inplace_vector<T, 0>;
 
   std::array<T, 10> arr;
   arr.fill(T{50});

tests/beman/inplace_vector/constructors.test.cpp

@@ -137,8 +137,8 @@ TYPED_TEST(Constructors, CopyRanges) {
 TYPED_TEST(Constructors, freestandingConversion) {
   using T = TestFixture::T;
 
-  using IV = beman::inplace_vector<T, 5>;
-  using FS = beman::freestanding::inplace_vector<T, 5>;
+  using IV = beman::inplace_vector::inplace_vector<T, 5>;
+  using FS = beman::inplace_vector::freestanding::inplace_vector<T, 5>;
 
   static_assert(std::is_constructible_v<FS, FS>);
   static_assert(std::is_constructible_v<IV, IV>);

tests/beman/inplace_vector/erasure.test.cpp

@@ -35,7 +35,7 @@ TYPED_TEST(Erasure, ByValue) {
       device.push_back(duplicates);
   }
 
-  beman::erase(device, duplicates);
+  beman::inplace_vector::erase(device, duplicates);
   EXPECT_EQ(uniques, device);
 }
 
@@ -59,8 +59,8 @@ TYPED_TEST(Erasure, ByPred) {
   for (auto i = 0; i < static_cast<int>(device.capacity()); ++i)
     device.push_back(T{i});
 
-  beman::erase_if(device,
-                  [&](auto &v) { return v.value > (device.capacity() / 2); });
+  beman::inplace_vector::erase_if(
+      device, [&](auto &v) { return v.value > (device.capacity() / 2); });
   EXPECT_TRUE(std::all_of(device.begin(), device.end(), [&](auto val) {
     return val.value <= (device.capacity() / 2);
   }));

tests/beman/inplace_vector/freestanding.test.cpp

@@ -137,8 +137,8 @@ concept has_insert_initializer =
 
 TEST(Freestanding, deleted) {
 
-  using IV = beman::inplace_vector<int, 10>;
-  using FIV = beman::freestanding::inplace_vector<int, 10>;
+  using IV = beman::inplace_vector::inplace_vector<int, 10>;
+  using FIV = beman::inplace_vector::freestanding::inplace_vector<int, 10>;
 
   using range = std::array<int, 10>;
   using input_iterator = std::istream_iterator<int>;
@@ -256,7 +256,7 @@ TEST(Freestanding, deleted) {
 }
 
 TEST(Freestanding, usage) {
-  using IV = beman::freestanding::inplace_vector<int, 10>;
+  using IV = beman::inplace_vector::freestanding::inplace_vector<int, 10>;
   using T = IV::value_type;
 
   IV device;

tests/beman/inplace_vector/gtest_setup.hpp

@@ -348,7 +348,7 @@ template <typename Param> class IVBasicTest : public ::testing::Test {
 public:
   using T = Param::value_type;
   inline static constexpr std::size_t N = Param::capacity;
-  using X = beman::inplace_vector<T, N>;
+  using X = beman::inplace_vector::inplace_vector<T, N>;
   using IV = X;
 
   // Returns IV of size n with unique values

tests/beman/inplace_vector/inplace_vector.test.cpp

@@ -2,7 +2,7 @@
 #include <beman/inplace_vector/inplace_vector.hpp>
 #include <cassert>
 
-using namespace beman;
+using namespace beman::inplace_vector;
 
 template <typename T> constexpr void test() {
   using vec = inplace_vector<T, 42>;