feat: zero relocation string containers

.github/workflows/linux.yml

@@ -1,6 +1,8 @@
-name: CI
+name: Linux
 
-on: [push]
+on:
+  push:
+  pull_request:
 
 jobs:
   build_frozen:
@@ -32,16 +34,13 @@ jobs:
       run: cmake -E make_directory build
 
     - name: Configure
-      working-directory: build
       env:
           CXX: ${{matrix.compiler}}
-          CXXFLAGS: -std=c++${{matrix.cxxstandard}}
-      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON ..
+          CXXFLAGS: -std=c++${{matrix.cxxstandard}} -fdiagnostics-color=always
+      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON -B build -S .
 
     - name: Build
-      working-directory: build
-      run: cmake --build .
+      run: cmake --build build
 
     - name: Test
-      working-directory: build
-      run: cmake --build . --target test
+      run: cmake --build build --target test

.github/workflows/osx.yml

@@ -1,6 +1,8 @@
-name: CI
+name: OSX
 
-on: [push]
+on:
+  push:
+  pull_request:
 
 jobs:
   build_frozen:
@@ -20,19 +22,13 @@ jobs:
       with:
         fetch-depth: 1
 
-    - name: Prepare
-      run: cmake -E make_directory build
-
     - name: Configure
-      working-directory: build
       env:
-          CXXFLAGS: -std=c++${{matrix.cxxstandard}}
-      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON ..
+          CXXFLAGS: -std=c++${{matrix.cxxstandard}} -fdiagnostics-color=always
+      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON -B build -S .
 
     - name: Build
-      working-directory: build
-      run: cmake --build .
+      run: cmake --build build
 
     - name: Test
-      working-directory: build
-      run: cmake --build . --target test
+      run: cmake --build build --target test

.github/workflows/windows.yml

@@ -1,6 +1,8 @@
-name: CI
+name: Windows
 
-on: [push]
+on:
+  push:
+  pull_request:
 
 jobs:
   build_frozen:
@@ -20,15 +22,10 @@ jobs:
       with:
         fetch-depth: 1
 
-    - name: Prepare
-      run: cmake -E make_directory build
-
     - name: Configure
-      working-directory: build
       env:
           CXXFLAGS: /std:c++${{matrix.cxxstandard}}
-      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON ..
+      run: cmake -DCMAKE_BUILD_TYPE=DEBUG "-Dfrozen.coverage=ON" -DCMAKE_VERBOSE_MAKEFILE=ON -B build -S .
 
     - name: Build
-      working-directory: build
-      run: cmake --build .
+      run: cmake --build build

examples/value_modification.cpp

@@ -18,13 +18,22 @@ MAYBE_CONSTINIT static frozen::unordered_map<frozen::string, int, 2> fruits = {
     {"n_pears", 0},
 };
 
+// Force conversion to a const reference. std::cref(ref).get() fails with libc++
+template <typename T>
+constexpr decltype(auto) const_ref(const T& ref) noexcept {
+  return ref;
+}
+
 int main() {
   // Update the values using at()
   fruits.at("n_apples") = 10;
   fruits.at("n_pears") = fruits.at("n_apples") * 2;
   std::cout << "n_apples: " << fruits.at("n_apples") << std::endl;
   std::cout << "n_pears: " << fruits.at("n_pears") << std::endl;
 
+  static_assert(std::is_same<decltype(const_ref(fruits).at("n_apples")), const int&>::value, "");
+  static_assert(std::is_same<decltype(fruits.at("n_apples")), int&>::value, "");
+
   // You can also update values via the iterator returned by find()
   auto found = fruits.find("n_apples");
   found->second = 0;
@@ -34,4 +43,4 @@ int main() {
   auto range = fruits.equal_range("n_apples");
   range.first->second = 1337;
   std::cout << "n_apples: " << fruits.at("n_apples") << std::endl;
-}
+}

include/frozen/bits/algorithms.h

@@ -229,6 +229,17 @@ constexpr bool lexicographical_compare(InputIt1 first1, InputIt1 last1, InputIt2
   return (first1 == last1) && (first2 != last2);
 }
 
+template <typename Int>
+constexpr Int accumulate(std::initializer_list<Int> items)
+{
+  Int sum {}; // zero or default init
+  for (const auto& item : items) {
+    sum += item;
+  }
+
+  return sum;
+}
+
 } // namespace bits
 } // namespace frozen
 

include/frozen/bits/basic_types.h

@@ -37,10 +37,58 @@ namespace bits {
 // used as a fake argument for frozen::make_set and frozen::make_map in the case of N=0
 struct ignored_arg {};
 
+constexpr std::size_t number_of_bits(std::size_t x)
+{
+    return x < 2 ? x : 1 + number_of_bits(x >> 1);
+}
+
+template <std::size_t total_size>
+struct size_integer {
+  static constexpr std::size_t needed_bits = number_of_bits(total_size);
+
+  using type = std::conditional_t<
+      needed_bits <= 8u
+    , std::uint8_t
+    , std::conditional_t<
+        needed_bits <= 16u
+      , std::uint16_t
+      , std::conditional_t<
+          needed_bits <= 32u
+        , std::uint32_t
+        , std::conditional_t<
+            needed_bits <= 64u
+          , std::uint64_t
+          , std::size_t // 128 bit system: don't know, but lets stop optimizing for size here
+          >
+        >
+      >
+    >;
+};
+
+template <std::size_t total_size>
+using size_integer_t = typename size_integer<total_size>::type;
+
+// Helper type to work around apparent compiler bugs in MSVC related to having "too complex"
+// template parameters involving either NTTP or references-to-array.
+template <class T, std::size_t N>
+struct array_ref {
+  using array_type = const T(&) [N];
+  using pointer = T*;
+
+  pointer array;
+
+  operator pointer   () const noexcept { return array; }
+  operator array_type() const noexcept { return array; }
+};
+
 template <class T, std::size_t N>
 class cvector {
+public:
+  using size_type = size_integer_t<N>;
+
+private:
   T data [N] = {}; // zero-initialization for scalar type T, default-initialized otherwise
-  std::size_t dsize = 0;
+  size_type dsize = 0;
 
 public:
   // Container typdefs
@@ -51,7 +99,6 @@ class cvector {
   using const_pointer = const value_type *;
   using iterator = pointer;
   using const_iterator = const_pointer;
-  using size_type = std::size_t;
   using difference_type = std::ptrdiff_t;
 
   // Constructors

include/frozen/bits/mpl.h

@@ -32,6 +32,8 @@ namespace bits {
 // Forward declarations
 template <class, std::size_t>
 class carray;
+template <typename T, std::size_t N, std::size_t string_size>
+struct pic_array;
 
 template <typename T>
 struct remove_cv : std::remove_cv<T> {};
@@ -46,9 +48,52 @@ struct remove_cv<carray<T, N>> {
   using type = carray<typename remove_cv<T>::type, N>;
 };
 
+template <typename T, std::size_t N, std::size_t string_size>
+struct remove_cv<pic_array<T, N, string_size>> {
+  using type = pic_array<typename remove_cv<T>::type, N, string_size>;
+};
+
 template <typename T>
 using remove_cv_t = typename remove_cv<T>::type;
 
+template <typename Container, typename ElemRef, typename Value>
+class copy_cv_iter_ref
+{
+private:
+  using cv_container = std::remove_reference_t<Container>;
+  using c_value = std::conditional_t<std::is_const<cv_container>::value, std::add_const_t<Value>, Value>;
+  using cv_value = std::conditional_t<std::is_volatile<cv_container>::value, std::add_volatile_t<c_value>, c_value>;
+  using cv_ref_value = std::conditional_t<std::is_lvalue_reference<ElemRef>::value, std::add_lvalue_reference_t<cv_value>, cv_value>;
+  using cv_rvref_value = std::conditional_t<
+      std::is_lvalue_reference<cv_ref_value>::value
+   && std::is_rvalue_reference<Container>::value
+   , std::add_rvalue_reference_t<cv_value>
+   , cv_ref_value>;
+public:
+  using type = cv_rvref_value;
+};
+
+template <typename Container, typename ElemRef, typename Value>
+using copy_cv_iter_ref_t = typename copy_cv_iter_ref<Container, ElemRef, Value>::type;
+
+struct has_type_selector
+{
+  // Relies on SFINAE to eliminate this overload when the type of it's first parameter does not
+  // have a 'type' member type.
+  template <class T>
+  static std::true_type test(const T&, typename T::type* = nullptr);
+  static std::false_type test(...);
+};
+
+template <class T>
+struct has_type : decltype(has_type_selector::test(std::declval<T>())) {};
+
+template <typename T>
+struct is_pair : std::false_type {};
+
+template <class... T>
+struct is_pair<std::pair<T...>> : std::true_type {};
+
 } // namespace bits
 
 } // namespace frozen