Template some methods to avoid boilerplate to_atom_key calls

Author: alexowens90

cpp/arcticdb/version/test/version_backwards_compat.hpp

@@ -28,15 +28,12 @@ inline std::optional<RefKey> get_symbol_ref_key(const std::shared_ptr<StreamSour
 std::deque<AtomKey> backwards_compat_delete_all_versions(
         const std::shared_ptr<Store>& store, std::shared_ptr<VersionMap>& version_map, const StreamId& stream_id
 ) {
-
+    std::deque<AtomKey> output;
     auto entry = version_map->check_reload(
             store, stream_id, LoadStrategy{LoadType::ALL, LoadObjective::INCLUDE_DELETED}, __FUNCTION__
     );
-    auto indexes = entry->get_indexes(false);
-    std::deque<AtomKey> output(indexes.size());
-    std::ranges::transform(indexes, output.begin(), [&stream_id](const auto& atom_key_packed) {
-        return atom_key_packed.to_atom_key(stream_id);
-    });
+    auto indexes = entry->template get_indexes<AtomKey>(false);
+    output.assign(std::begin(indexes), std::end(indexes));
 
     if (auto ref_key = get_symbol_ref_key(store, stream_id); ref_key) {
         store->remove_key(*ref_key).wait();
@@ -51,7 +48,6 @@ std::vector<AtomKey> backwards_compat_write_and_prune_previous(
 ) {
     const auto& sym = key.id();
     log::version().debug("Version map pruning previous versions for stream {}", key.id());
-
     auto entry = version_map->check_reload(
             store, sym, LoadStrategy{LoadType::ALL, LoadObjective::INCLUDE_DELETED}, __FUNCTION__
     );
@@ -61,11 +57,7 @@ std::vector<AtomKey> backwards_compat_write_and_prune_previous(
     version_map->do_write(store, key, entry);
     write_symbol_ref(store, key, std::nullopt, entry->head_.value());
     version_map->remove_entry_version_keys(store, old_entry, sym);
-    auto output_packed = old_entry.get_indexes(false);
-    std::vector<AtomKey> output(output_packed.size());
-    std::ranges::transform(output_packed, output.begin(), [&sym](const auto& atom_key_packed) {
-        return atom_key_packed.to_atom_key(sym);
-    });
+    auto output = old_entry.template get_indexes<AtomKey>(false);
 
     if (version_map->log_changes())
         log_write(store, sym, key.version_id());

cpp/arcticdb/version/version_functions.hpp

@@ -50,13 +50,14 @@ inline version_store::UpdateInfo get_latest_undeleted_version_and_next_version_i
     return {latest_undeleted_version, next_version_id};
 }
 
-inline std::vector<AtomKeyPacked> get_all_versions(
+template<AtomKeyType T = AtomKeyPacked>
+std::vector<T> get_all_versions(
         const std::shared_ptr<Store>& store, const std::shared_ptr<VersionMap>& version_map, const StreamId& stream_id
 ) {
     ARCTICDB_SAMPLE(GetAllVersions, 0)
     LoadStrategy load_strategy{LoadType::ALL, LoadObjective::UNDELETED_ONLY};
     auto entry = version_map->check_reload(store, stream_id, load_strategy, __FUNCTION__);
-    return entry->get_indexes(false);
+    return entry->template get_indexes<T>(false);
 }
 
 inline std::optional<AtomKey> get_specific_version(
@@ -131,8 +132,8 @@ inline std::unordered_map<VersionId, bool> get_all_tombstoned_versions(
     LoadStrategy load_strategy{LoadType::ALL, LoadObjective::INCLUDE_DELETED};
     auto entry = version_map->check_reload(store, stream_id, load_strategy, __FUNCTION__);
     std::unordered_map<VersionId, bool> result;
-    for (auto key : entry->get_tombstoned_indexes())
-        result[key.version_id()] = store->key_exists(key.to_atom_key(stream_id)).get();
+    for (const auto& key : entry->template get_tombstoned_indexes<AtomKey>())
+        result[key.version_id()] = store->key_exists(key).get();
 
     return result;
 }

cpp/arcticdb/version/version_map_entry.hpp

@@ -324,20 +324,31 @@ struct VersionMapEntry {
         keys_.push_front(key);
     }
 
-    std::vector<AtomKeyPacked> get_indexes(bool include_deleted) const {
-        std::vector<AtomKeyPacked> output;
+    template<AtomKeyType T = AtomKeyPacked>
+    std::vector<T> get_indexes(bool include_deleted) const {
+        std::vector<T> output;
         for (const auto& key : keys_) {
-            if (is_index_key_type(key.type()) && (include_deleted || !is_tombstoned(key)))
-                output.emplace_back(key);
+            if (is_index_key_type(key.type()) && (include_deleted || !is_tombstoned(key))) {
+                if constexpr (std::is_same_v<T, AtomKey>) {
+                    output.emplace_back(key.to_atom_key(stream_id_));
+                } else {
+                    output.emplace_back(key);
+                }
+            }
         }
         return output;
     }
 
-    std::vector<AtomKeyPacked> get_tombstoned_indexes() const {
-        std::vector<AtomKeyPacked> output;
+    template<AtomKeyType T = AtomKeyPacked>
+    std::vector<T> get_tombstoned_indexes() const {
+        std::vector<T> output;
         for (const auto& key : keys_) {
-            if (is_index_key_type(key.type()) && is_tombstoned(key))
-                output.emplace_back(key);
+            if (is_index_key_type(key.type()) && is_tombstoned(key)) {
+                if constexpr (std::is_same_v<T, AtomKey>) {
+                    output.emplace_back(key.to_atom_key(stream_id_));
+                } else {
+                    output.emplace_back(key);
+                }            }
         }
         return output;
     }