Add repository::get_file

crates/core/src/backend/decrypt.rs

@@ -133,7 +133,7 @@ pub trait DecryptReadBackend: ReadBackend + Clone + 'static {
     /// # Errors
     ///
     /// * If the file could not be read.
-    fn get_file<F: RepoFile>(&self, id: &Id) -> RusticResult<F> {
+    fn get_file<F: RepoFile>(&self, id: &F::Id) -> RusticResult<F> {
         let data = if F::ENCRYPTED {
             self.read_encrypted_full(F::TYPE, id)?
         } else {
@@ -163,6 +163,7 @@ pub trait DecryptReadBackend: ReadBackend + Clone + 'static {
     /// If the files could not be read.
     fn stream_all<F: RepoFile>(&self, p: &impl Progress) -> StreamResult<F::Id, F> {
         let list = self.list(F::TYPE)?;
+        let list: Vec<_> = list.into_iter().map(F::Id::from).collect();
         self.stream_list(&list, p)
     }
 
@@ -178,13 +179,17 @@ pub trait DecryptReadBackend: ReadBackend + Clone + 'static {
     /// # Errors
     ///
     /// If the files could not be read.
-    fn stream_list<F: RepoFile>(&self, list: &[Id], p: &impl Progress) -> StreamResult<F::Id, F> {
+    fn stream_list<F: RepoFile>(
+        &self,
+        list: &[F::Id],
+        p: &impl Progress,
+    ) -> StreamResult<F::Id, F> {
         p.set_length(list.len() as u64);
         let (tx, rx) = unbounded();
 
         list.into_par_iter()
             .for_each_with((self, p, tx), |(be, p, tx), id| {
-                let file = be.get_file::<F>(id).map(|file| (F::Id::from(*id), file));
+                let file = be.get_file::<F>(id).map(|file| (*id, file));
                 p.inc(1);
                 tx.send(file).unwrap();
             });

crates/core/src/commands/prune.rs

@@ -1587,7 +1587,8 @@ fn find_used_blobs(
     let list: Vec<_> = be
         .list(FileType::Snapshot)?
         .into_iter()
-        .filter(|id| !ignore_snaps.contains(&SnapshotId::from(*id)))
+        .map(SnapshotId::from)
+        .filter(|id| !ignore_snaps.contains(&id))
         .collect();
     let snap_trees: Vec<_> = be
         .stream_list::<SnapshotFile>(&list, &p)?

crates/core/src/repofile.rs

@@ -15,11 +15,11 @@ pub trait RepoFile: Serialize + DeserializeOwned + Sized + Send + Sync + 'static
     /// Indicate whether the files are stored encrypted
     const ENCRYPTED: bool = true;
     /// The Id type associated with the repository file
-    type Id: From<Id> + Send;
+    type Id: RepoId;
 }
 
 /// Marker trait for Ids which identify repository files
-pub trait RepoId: Deref<Target = Id> + From<Id> + Sized + Send + Sync + 'static {
+pub trait RepoId: Deref<Target = Id> + From<Id> + Sized + Copy + Send + Sync + 'static {
     /// The [`FileType`] associated with Id type
     const TYPE: FileType;
 }

crates/core/src/repofile/snapshotfile.rs

@@ -671,8 +671,8 @@ impl SnapshotFile {
         let mut snaps: BTreeMap<_, _> = current.into_iter().map(|snap| (snap.id, snap)).collect();
         let missing_ids: Vec<_> = ids
             .iter()
-            .filter(|id| !snaps.contains_key(&SnapshotId::from(**id)))
-            .copied()
+            .map(|id| SnapshotId::from(*id))
+            .filter(|id| !snaps.contains_key(id))
             .collect();
         for res in be.stream_list::<Self>(&missing_ids, p)? {
             let (id, snap) = res?;

crates/core/src/repository.rs

@@ -1354,6 +1354,19 @@ impl<P: ProgressBars, S: Open> Repository<P, S> {
         commands::repoinfo::collect_index_infos(self)
     }
 
+    /// Read a given [`RepoFile`]
+    ///
+    /// # Errors
+    ///
+    /// If the file cannot be read or processed
+    ///
+    /// # Returns
+    ///
+    /// The file
+    pub fn get_file<F: RepoFile>(&self, id: &F::Id) -> RusticResult<F> {
+        self.dbe().get_file(id)
+    }
+
     /// Read all files of a given [`RepoFile`]
     ///
     /// # Errors