Rename immer-archive into just archive

extra/fuzzer/CMakeLists.txt

@@ -14,7 +14,7 @@ endif()
 
 file(GLOB_RECURSE immer_fuzzers "*.cpp")
 foreach(TMP_PATH ${immer_fuzzers})
-  string(FIND ${TMP_PATH} immer-archive EXCLUDE_DIR_FOUND)
+  string(FIND ${TMP_PATH} archive EXCLUDE_DIR_FOUND)
   if(NOT ${EXCLUDE_DIR_FOUND} EQUAL -1)
     list(REMOVE_ITEM immer_fuzzers ${TMP_PATH})
   endif()
@@ -37,5 +37,5 @@ foreach(_file IN LISTS immer_fuzzers)
 endforeach()
 
 if(immer_BUILD_ARCHIVE_TESTS)
-  add_subdirectory(immer-archive)
+  add_subdirectory(archive)
 endif()

extra/fuzzer/immer-archive/flex-vector.cpp → extra/fuzzer/archive/flex-vector.cpp

@@ -12,8 +12,8 @@
 #include <immer/flex_vector.hpp>
 
 #include <fmt/ranges.h>
-#include <immer/experimental/immer-archive/rbts/load.hpp>
-#include <immer/experimental/immer-archive/rbts/save.hpp>
+#include <immer/extra/archive/rbts/load.hpp>
+#include <immer/extra/archive/rbts/save.hpp>
 
 #include <array>
 
@@ -38,12 +38,13 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data,
     using size_t = std::uint8_t;
 
     const auto check_save_and_load = [&](const auto& vec) {
-        auto ar        = immer_archive::rbts::make_save_archive_for(vec);
-        auto vector_id = immer_archive::container_id{};
-        std::tie(ar, vector_id) = immer_archive::rbts::save_to_archive(vec, ar);
+        auto ar        = immer::archive::rbts::make_save_archive_for(vec);
+        auto vector_id = immer::archive::container_id{};
+        std::tie(ar, vector_id) =
+            immer::archive::rbts::save_to_archive(vec, ar);
 
         auto loader =
-            immer_archive::rbts::make_loader_for(vec, to_load_archive(ar));
+            immer::archive::rbts::make_loader_for(vec, to_load_archive(ar));
         auto loaded = loader.load(vector_id);
         require_eq(vec, loaded);
     };

extra/fuzzer/immer-archive/fuzz-set.cpp → extra/fuzzer/archive/fuzz-set.cpp

@@ -1,6 +1,6 @@
 #include <fuzzer/fuzzer_input.hpp>
 
-#include <immer/experimental/immer-archive/champ/champ.hpp>
+#include <immer/extra/archive/champ/champ.hpp>
 
 #include <array>
 #include <bitset>
@@ -77,20 +77,20 @@ extern "C" int LLVMFuzzerTestOneInput(const std::uint8_t* data,
         case op_check: {
             const auto bitset = std::bitset<var_count>(read<size_t>(in));
             auto ids =
-                std::vector<std::pair<std::size_t, immer_archive::node_id>>{};
+                std::vector<std::pair<std::size_t, immer::archive::node_id>>{};
             auto archive =
-                immer_archive::champ::container_archive_save<set_t>{};
+                immer::archive::champ::container_archive_save<set_t>{};
             for (auto index = std::size_t{}; index < var_count; ++index) {
                 if (bitset[index]) {
-                    auto set_id = immer_archive::node_id{};
+                    auto set_id = immer::archive::node_id{};
                     std::tie(archive, set_id) =
-                        immer_archive::champ::save_to_archive(vars[index],
-                                                              archive);
+                        immer::archive::champ::save_to_archive(vars[index],
+                                                               archive);
                     ids.emplace_back(index, set_id);
                 }
             }
 
-            auto loader = immer_archive::champ::container_loader<set_t>{
+            auto loader = immer::archive::champ::container_loader<set_t>{
                 to_load_archive(archive)};
 
             for (const auto& [index, set_id] : ids) {

flake.nix

@@ -48,7 +48,7 @@
 
       arximboldi-cereal = pkgs.callPackage ./nix/cereal.nix {inherit arximboldi-cereal-src;};
 
-      immer-archive-inputs = with pkgs; [
+      archive-inputs = with pkgs; [
         spdlog
         arximboldi-cereal
         xxHash
@@ -74,8 +74,8 @@
             checkPhase = ''
               ctest -D ExperimentalMemCheck
               valgrind --quiet --error-exitcode=99 --leak-check=full --errors-for-leak-kinds=all \
-                --suppressions=./test/experimental/immer-archive/valgrind.supp \
-                ./test/experimental/immer-archive/immer-archive-tests
+                --suppressions=./test/extra/archive/valgrind.supp \
+                ./test/extra/archive/archive-tests
             '';
           });
         };
@@ -98,7 +98,7 @@
             fzf
             starship
           ]
-          ++ immer-archive-inputs;
+          ++ archive-inputs;
 
         shellHook =
           self.checks.${system}.pre-commit-check.shellHook
@@ -142,7 +142,7 @@
 
         unit-tests = (withLLVM self.packages.${system}.immer).overrideAttrs (prev: {
           name = "immer-unit-tests";
-          buildInputs = with pkgs; [catch2_3 boehmgc boost fmt] ++ immer-archive-inputs;
+          buildInputs = with pkgs; [catch2_3 boehmgc boost fmt] ++ archive-inputs;
           nativeBuildInputs = with pkgs; [cmake ninja];
           dontBuild = false;
           doCheck = true;

immer/experimental/immer-archive/alias.hpp → immer/extra/archive/alias.hpp

@@ -2,7 +2,7 @@
 
 #include <fmt/format.h>
 
-namespace immer_archive {
+namespace immer::archive {
 
 template <class T, class Tag>
 struct type_alias
@@ -41,26 +41,26 @@ struct type_alias
     }
 };
 
-} // namespace immer_archive
+} // namespace immer::archive
 
 /**
  * Have to use this for fmt v9.
  */
 template <class T, class Tag>
-struct fmt::formatter<immer_archive::type_alias<T, Tag>> : formatter<T>
+struct fmt::formatter<immer::archive::type_alias<T, Tag>> : formatter<T>
 {
     template <typename FormatContext>
-    auto format(const immer_archive::type_alias<T, Tag>& value,
+    auto format(const immer::archive::type_alias<T, Tag>& value,
                 FormatContext& ctx) const
     {
         return formatter<T>::format(value.value, ctx);
     }
 };
 
 template <class T, class Tag>
-struct std::hash<immer_archive::type_alias<T, Tag>>
+struct std::hash<immer::archive::type_alias<T, Tag>>
 {
-    auto operator()(const immer_archive::type_alias<T, Tag>& x) const
+    auto operator()(const immer::archive::type_alias<T, Tag>& x) const
     {
         return hash<T>{}(x.value);
     }

immer/experimental/immer-archive/box/archive.hpp → immer/extra/archive/box/archive.hpp

@@ -1,16 +1,16 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/common/archive.hpp>
-#include <immer/experimental/immer-archive/errors.hpp>
-#include <immer/experimental/immer-archive/traits.hpp>
+#include <immer/extra/archive/common/archive.hpp>
+#include <immer/extra/archive/errors.hpp>
+#include <immer/extra/archive/traits.hpp>
 
 #include <immer/box.hpp>
 #include <immer/map.hpp>
 #include <immer/vector.hpp>
 
 #include <cereal/cereal.hpp>
 
-namespace immer_archive::box {
+namespace immer::archive::box {
 
 template <typename T, typename MemoryPolicy>
 struct archive_save
@@ -143,17 +143,17 @@ loader<T, MemoryPolicy> make_loader_for(const immer::box<T, MemoryPolicy>&,
     return loader<T, MemoryPolicy>{std::move(ar)};
 }
 
-} // namespace immer_archive::box
+} // namespace immer::archive::box
 
-namespace immer_archive {
+namespace immer::archive {
 
 template <typename T, typename MemoryPolicy>
 struct container_traits<immer::box<T, MemoryPolicy>>
 {
     using save_archive_t = box::archive_save<T, MemoryPolicy>;
     using load_archive_t = box::archive_load<T, MemoryPolicy>;
     using loader_t       = box::loader<T, MemoryPolicy>;
-    using container_id   = immer_archive::container_id;
+    using container_id   = immer::archive::container_id;
 };
 
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/champ/archive.hpp → immer/extra/archive/champ/archive.hpp

@@ -1,18 +1,18 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/common/archive.hpp>
+#include <immer/extra/archive/common/archive.hpp>
 
 #include <immer/map.hpp>
 #include <immer/set.hpp>
 #include <immer/table.hpp>
 #include <immer/vector.hpp>
 
 #include <cereal/cereal.hpp>
-#include <immer/experimental/immer-archive/cereal/immer_vector.hpp>
+#include <immer/extra/archive/cereal/immer_vector.hpp>
 
 #include <boost/endian/conversion.hpp>
 
-namespace immer_archive {
+namespace immer::archive {
 namespace champ {
 
 template <class T, immer::detail::hamts::bits_t B>
@@ -250,4 +250,4 @@ auto transform_archive(const container_archive_load<
 }
 
 } // namespace champ
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/champ/champ.hpp → immer/extra/archive/champ/champ.hpp

@@ -6,7 +6,7 @@
 
 #include <optional>
 
-namespace immer_archive {
+namespace immer::archive {
 namespace champ {
 
 template <class Node>
@@ -139,4 +139,4 @@ save_to_archive(Container container, container_archive_save<Container> archive)
 }
 
 } // namespace champ
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/champ/load.hpp → immer/extra/archive/champ/load.hpp

@@ -1,15 +1,15 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/champ/archive.hpp>
-#include <immer/experimental/immer-archive/errors.hpp>
-#include <immer/experimental/immer-archive/node_ptr.hpp>
+#include <immer/extra/archive/champ/archive.hpp>
+#include <immer/extra/archive/errors.hpp>
+#include <immer/extra/archive/node_ptr.hpp>
 
 #include <immer/flex_vector.hpp>
 
 #include <boost/range/adaptor/indexed.hpp>
 #include <spdlog/spdlog.h>
 
-namespace immer_archive {
+namespace immer::archive {
 namespace champ {
 
 class children_count_corrupted_exception : public archive_exception
@@ -61,7 +61,7 @@ class nodes_loader
     using champ_t =
         immer::detail::hamts::champ<T, Hash, Equal, MemoryPolicy, B>;
     using node_t   = typename champ_t::node_t;
-    using node_ptr = immer_archive::node_ptr<node_t>;
+    using node_ptr = immer::archive::node_ptr<node_t>;
 
     using values_t = immer::flex_vector<immer::array<T>>;
 
@@ -224,4 +224,4 @@ class nodes_loader
 };
 
 } // namespace champ
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/champ/save.hpp → immer/extra/archive/champ/save.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/champ/archive.hpp>
+#include <immer/extra/archive/champ/archive.hpp>
 
 #include <spdlog/spdlog.h>
 
-namespace immer_archive {
+namespace immer::archive {
 namespace champ {
 
 template <class T, immer::detail::hamts::bits_t B>
@@ -70,7 +70,7 @@ struct nodes_archive_builder
 
     node_id get_node_id(auto* ptr)
     {
-        auto [ar2, id] = immer_archive::champ::get_node_id(std::move(ar), ptr);
+        auto [ar2, id] = immer::archive::champ::get_node_id(std::move(ar), ptr);
         ar             = std::move(ar2);
         return id;
     }
@@ -98,4 +98,4 @@ auto save_nodes(
 }
 
 } // namespace champ
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/champ/traits.hpp → immer/extra/archive/champ/traits.hpp

@@ -1,20 +1,20 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/champ/archive.hpp>
-#include <immer/experimental/immer-archive/champ/champ.hpp>
-#include <immer/experimental/immer-archive/traits.hpp>
+#include <immer/extra/archive/champ/archive.hpp>
+#include <immer/extra/archive/champ/champ.hpp>
+#include <immer/extra/archive/traits.hpp>
 
-namespace immer_archive {
+namespace immer::archive {
 
 template <class Container>
 struct champ_traits
 {
     using save_archive_t =
-        immer_archive::champ::container_archive_save<Container>;
+        immer::archive::champ::container_archive_save<Container>;
     using load_archive_t =
-        immer_archive::champ::container_archive_load<Container>;
-    using loader_t     = immer_archive::champ::container_loader<Container>;
-    using container_id = immer_archive::node_id;
+        immer::archive::champ::container_archive_load<Container>;
+    using loader_t     = immer::archive::champ::container_loader<Container>;
+    using container_id = immer::archive::node_id;
 };
 
 template <typename K,
@@ -37,4 +37,4 @@ struct container_traits<immer::table<T, KeyFn, Hash, Equal, MemoryPolicy, B>>
     : champ_traits<immer::table<T, KeyFn, Hash, Equal, MemoryPolicy, B>>
 {};
 
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/common/archive.hpp → immer/extra/archive/common/archive.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/alias.hpp>
+#include <immer/extra/archive/alias.hpp>
 
 #include <immer/array.hpp>
 #include <immer/map.hpp>
 
 #include <cereal/types/utility.hpp>
 
-namespace immer_archive {
+namespace immer::archive {
 
 struct node_id_tag;
 using node_id = type_alias<std::size_t, node_id_tag>;
@@ -97,4 +97,4 @@ auto transform(const immer::map<node_id, values_load<T>>& map, F&& func)
     return result;
 }
 
-} // namespace immer_archive
+} // namespace immer::archive

immer/experimental/immer-archive/errors.hpp → immer/extra/archive/errors.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <immer/experimental/immer-archive/common/archive.hpp>
+#include <immer/extra/archive/common/archive.hpp>
 
 #include <stdexcept>
 
 #include <fmt/format.h>
 
-namespace immer_archive {
+namespace immer::archive {
 
 class archive_exception : public std::invalid_argument
 {
@@ -51,4 +51,4 @@ class invalid_children_count : public archive_exception
     }
 };
 
-} // namespace immer_archive
+} // namespace immer::archive