refactor!: Use different Id types

crates/backend/src/local.rs

@@ -171,8 +171,7 @@ impl ReadBackend for LocalBackend {
             .into_iter()
             .filter_map(walkdir::Result::ok)
             .filter(|e| e.file_type().is_file())
-            .map(|e| Id::from_hex(&e.file_name().to_string_lossy()))
-            .filter_map(std::result::Result::ok);
+            .filter_map(|e| e.file_name().to_string_lossy().parse::<Id>().ok());
         Ok(walker.collect())
     }
 
@@ -216,7 +215,7 @@ impl ReadBackend for LocalBackend {
             .filter(|e| e.file_type().is_file())
             .map(|e| -> Result<_> {
                 Ok((
-                    Id::from_hex(&e.file_name().to_string_lossy())?,
+                    e.file_name().to_string_lossy().parse()?,
                     e.metadata()
                         .map_err(LocalBackendErrorKind::QueryingWalkDirMetadataFailed)?
                         .len()

crates/backend/src/opendal.rs

@@ -171,8 +171,7 @@ impl ReadBackend for OpenDALBackend {
             .call()?
             .into_iter()
             .filter(|e| e.metadata().is_file())
-            .map(|e| Id::from_hex(e.name()))
-            .filter_map(Result::ok)
+            .filter_map(|e| e.name().parse().ok())
             .collect())
     }
 
@@ -201,10 +200,7 @@ impl ReadBackend for OpenDALBackend {
             .into_iter()
             .filter(|e| e.metadata().is_file())
             .map(|e| -> Result<(Id, u32)> {
-                Ok((
-                    Id::from_hex(e.name())?,
-                    e.metadata().content_length().try_into()?,
-                ))
+                Ok((e.name().parse()?, e.metadata().content_length().try_into()?))
             })
             .filter_map(Result::ok)
             .collect())

crates/backend/src/rest.rs

@@ -289,7 +289,7 @@ impl ReadBackend for RestBackend {
                     .unwrap_or_default();
                 Ok(list
                     .into_iter()
-                    .filter_map(|i| match Id::from_hex(&i.name) {
+                    .filter_map(|i| match i.name.parse::<Id>() {
                         Ok(id) => Some((id, i.size)),
                         Err(_) => None,
                     })

crates/core/Cargo.toml

@@ -46,7 +46,7 @@ thiserror = "1.0.63"
 
 # macros
 derivative = "2.2.0"
-derive_more = { version = "1.0.0", features = ["add", "constructor", "display"] }
+derive_more = { version = "1.0.0", features = ["add", "constructor", "display", "from", "deref", "from_str"] }
 derive_setters = "0.1.6"
 
 # logging

crates/core/src/archiver.rs

@@ -218,7 +218,7 @@ impl<'a, BE: DecryptFullBackend, I: ReadGlobalIndex> Archiver<'a, BE, I> {
 
         if !skip_identical_parent || Some(self.snap.tree) != self.parent.tree_id() {
             let id = self.be.save_file(&self.snap)?;
-            self.snap.id = id;
+            self.snap.id = id.into();
         }
 
         p.finish();

crates/core/src/archiver/file_archiver.rs

@@ -13,7 +13,7 @@ use crate::{
     },
     blob::{
         packer::{Packer, PackerStats},
-        BlobType,
+        BlobId, BlobType, DataId,
     },
     cdc::rolling_hash::Rabin64,
     chunker::ChunkIter,
@@ -147,11 +147,11 @@ impl<'a, BE: DecryptWriteBackend, I: ReadGlobalIndex> FileArchiver<'a, BE, I> {
             let id = hash(&chunk);
             let size = chunk.len() as u64;
 
-            if !self.index.has_data(&id) {
-                self.data_packer.add(chunk.into(), id)?;
+            if !self.index.has_data(&DataId::from(id)) {
+                self.data_packer.add(chunk.into(), BlobId::from(id))?;
             }
             p.inc(size);
-            Ok((id, size))
+            Ok((DataId::from(id), size))
         })
         .collect::<RusticResult<_>>()?;
 

crates/core/src/archiver/parent.rs

@@ -8,9 +8,8 @@ use log::warn;
 use crate::{
     archiver::tree::TreeType,
     backend::{decrypt::DecryptReadBackend, node::Node},
-    blob::tree::Tree,
+    blob::tree::{Tree, TreeId},
     error::{ArchiverErrorKind, RusticResult},
-    id::Id,
     index::ReadGlobalIndex,
 };
 
@@ -19,13 +18,13 @@ use crate::{
 /// # Type Parameters
 ///
 /// * `O` - The type of the `TreeType`.
-pub(crate) type ItemWithParent<O> = TreeType<(O, ParentResult<()>), ParentResult<Id>>;
+pub(crate) type ItemWithParent<O> = TreeType<(O, ParentResult<()>), ParentResult<TreeId>>;
 
 /// The `Parent` is responsible for finding the parent tree of a given tree.
 #[derive(Debug)]
 pub struct Parent {
     /// The tree id of the parent tree.
-    tree_id: Option<Id>,
+    tree_id: Option<TreeId>,
     /// The parent tree.
     tree: Option<Tree>,
     /// The current node index.
@@ -92,7 +91,7 @@ impl Parent {
     pub(crate) fn new(
         be: &impl DecryptReadBackend,
         index: &impl ReadGlobalIndex,
-        tree_id: Option<Id>,
+        tree_id: Option<TreeId>,
         ignore_ctime: bool,
         ignore_inode: bool,
     ) -> Self {
@@ -235,7 +234,7 @@ impl Parent {
     }
 
     // TODO: add documentation!
-    pub(crate) fn tree_id(&self) -> Option<Id> {
+    pub(crate) fn tree_id(&self) -> Option<TreeId> {
         self.tree_id
     }
 

crates/core/src/archiver/tree_archiver.rs

@@ -6,14 +6,17 @@ use log::{debug, trace};
 use crate::{
     archiver::{parent::ParentResult, tree::TreeType},
     backend::{decrypt::DecryptWriteBackend, node::Node},
-    blob::{packer::Packer, tree::Tree, BlobType},
+    blob::{
+        packer::Packer,
+        tree::{Tree, TreeId},
+        BlobType,
+    },
     error::{ArchiverErrorKind, RusticResult},
-    id::Id,
     index::{indexer::SharedIndexer, ReadGlobalIndex},
     repofile::{configfile::ConfigFile, snapshotfile::SnapshotSummary},
 };
 
-pub(crate) type TreeItem = TreeType<(ParentResult<()>, u64), ParentResult<Id>>;
+pub(crate) type TreeItem = TreeType<(ParentResult<()>, u64), ParentResult<TreeId>>;
 
 /// The `TreeArchiver` is responsible for archiving trees.
 ///
@@ -27,7 +30,7 @@ pub(crate) struct TreeArchiver<'a, BE: DecryptWriteBackend, I: ReadGlobalIndex>
     /// The current tree.
     tree: Tree,
     /// The stack of trees.
-    stack: Vec<(PathBuf, Node, ParentResult<Id>, Tree)>,
+    stack: Vec<(PathBuf, Node, ParentResult<TreeId>, Tree)>,
     /// The index to read from.
     index: &'a I,
     /// The packer to write to.
@@ -168,7 +171,7 @@ impl<'a, BE: DecryptWriteBackend, I: ReadGlobalIndex> TreeArchiver<'a, BE, I> {
     /// The id of the tree.
     ///
     /// [`PackerErrorKind::SendingCrossbeamMessageFailed`]: crate::error::PackerErrorKind::SendingCrossbeamMessageFailed
-    fn backup_tree(&mut self, path: &Path, parent: &ParentResult<Id>) -> RusticResult<Id> {
+    fn backup_tree(&mut self, path: &Path, parent: &ParentResult<TreeId>) -> RusticResult<TreeId> {
         let (chunk, id) = self.tree.serialize()?;
         let dirsize = chunk.len() as u64;
         let dirsize_bytes = ByteSize(dirsize).to_string_as(true);
@@ -193,7 +196,7 @@ impl<'a, BE: DecryptWriteBackend, I: ReadGlobalIndex> TreeArchiver<'a, BE, I> {
         }
 
         if !self.index.has_tree(&id) {
-            self.tree_packer.add(chunk.into(), id)?;
+            self.tree_packer.add(chunk.into(), id.into())?;
         }
         Ok(id)
     }
@@ -219,8 +222,8 @@ impl<'a, BE: DecryptWriteBackend, I: ReadGlobalIndex> TreeArchiver<'a, BE, I> {
     /// [`PackerErrorKind::SendingCrossbeamMessageFailed`]: crate::error::PackerErrorKind::SendingCrossbeamMessageFailed
     pub(crate) fn finalize(
         mut self,
-        parent_tree: Option<Id>,
-    ) -> RusticResult<(Id, SnapshotSummary)> {
+        parent_tree: Option<TreeId>,
+    ) -> RusticResult<(TreeId, SnapshotSummary)> {
         let parent = parent_tree.map_or(ParentResult::NotFound, ParentResult::Matched);
         let id = self.backup_tree(&PathBuf::new(), &parent)?;
         let stats = self.tree_packer.finalize()?;

crates/core/src/backend.rs

@@ -277,7 +277,7 @@ pub trait FindInBackend: ReadBackend {
     /// [`BackendAccessErrorKind::IdNotUnique`]: crate::error::BackendAccessErrorKind::IdNotUnique
     fn find_ids<T: AsRef<str>>(&self, tpe: FileType, ids: &[T]) -> RusticResult<Vec<Id>> {
         ids.iter()
-            .map(|id| Id::from_hex(id.as_ref()))
+            .map(|id| id.as_ref().parse())
             .collect::<RusticResult<Vec<_>>>()
             .or_else(|err|{
                 trace!("no valid IDs given: {err}, searching for ID starting with given strings instead");

crates/core/src/backend/cache.rs

@@ -16,6 +16,7 @@ use crate::{
     backend::{FileType, ReadBackend, WriteBackend},
     error::{CacheBackendErrorKind, RusticResult},
     id::Id,
+    repofile::configfile::RepositoryId,
 };
 
 /// Backend that caches data.
@@ -235,7 +236,7 @@ impl Cache {
     ///
     /// [`CacheBackendErrorKind::NoCacheDirectory`]: crate::error::CacheBackendErrorKind::NoCacheDirectory
     /// [`CacheBackendErrorKind::FromIoError`]: crate::error::CacheBackendErrorKind::FromIoError
-    pub fn new(id: Id, path: Option<PathBuf>) -> RusticResult<Self> {
+    pub fn new(id: RepositoryId, path: Option<PathBuf>) -> RusticResult<Self> {
         let mut path = path.unwrap_or({
             let mut dir = cache_dir().ok_or_else(|| CacheBackendErrorKind::NoCacheDirectory)?;
             dir.push("rustic");
@@ -318,7 +319,7 @@ impl Cache {
             })
             .map(|e| {
                 (
-                    Id::from_hex(e.file_name().to_str().unwrap()).unwrap(),
+                    e.file_name().to_str().unwrap().parse().unwrap(),
                     // handle errors in metadata by returning a size of 0
                     e.metadata().map_or(0, |m| m.len().try_into().unwrap_or(0)),
                 )

crates/core/src/backend/decrypt.rs

@@ -19,7 +19,7 @@ use crate::{
     crypto::{hasher::hash, CryptoKey},
     error::{CryptBackendErrorKind, RusticErrorKind},
     id::Id,
-    repofile::RepoFile,
+    repofile::{RepoFile, RepoId},
     Progress, RusticResult,
 };
 
@@ -31,6 +31,8 @@ pub trait DecryptFullBackend: DecryptWriteBackend + DecryptReadBackend {}
 
 impl<T: DecryptWriteBackend + DecryptReadBackend> DecryptFullBackend for T {}
 
+pub type StreamResult<Id, F> = RusticResult<Receiver<RusticResult<(Id, F)>>>;
+
 pub trait DecryptReadBackend: ReadBackend + Clone + 'static {
     /// Decrypts the given data.
     ///
@@ -142,10 +144,7 @@ pub trait DecryptReadBackend: ReadBackend + Clone + 'static {
     /// # Errors
     ///
     /// If the files could not be read.
-    fn stream_all<F: RepoFile>(
-        &self,
-        p: &impl Progress,
-    ) -> RusticResult<Receiver<RusticResult<(Id, F)>>> {
+    fn stream_all<F: RepoFile>(&self, p: &impl Progress) -> StreamResult<F::Id, F> {
         let list = self.list(F::TYPE).map_err(RusticErrorKind::Backend)?;
         self.stream_list(&list, p)
     }
@@ -162,17 +161,13 @@ 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,
-    ) -> RusticResult<Receiver<RusticResult<(Id, F)>>> {
+    fn stream_list<F: RepoFile>(&self, list: &[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| (*id, file));
+                let file = be.get_file::<F>(id).map(|file| (F::Id::from(*id), file));
                 p.inc(1);
                 tx.send(file).unwrap();
             });
@@ -311,17 +306,16 @@ pub trait DecryptWriteBackend: WriteBackend + Clone + 'static {
     /// # Panics
     ///
     /// If the files could not be deleted.
-    fn delete_list<'a, I: ExactSizeIterator<Item = &'a Id> + Send>(
+    fn delete_list<'a, ID: RepoId, I: ExactSizeIterator<Item = &'a ID> + Send>(
         &self,
-        tpe: FileType,
         cacheable: bool,
         list: I,
         p: impl Progress,
     ) -> RusticResult<()> {
         p.set_length(list.len() as u64);
         list.par_bridge().try_for_each(|id| -> RusticResult<_> {
             // TODO: Don't panic on file not being able to be deleted.
-            self.remove(tpe, id, cacheable).unwrap();
+            self.remove(ID::TYPE, id, cacheable).unwrap();
             p.inc(1);
             Ok(())
         })?;

crates/core/src/backend/node.rs

@@ -27,7 +27,7 @@ use serde_with::{
 #[cfg(not(windows))]
 use crate::error::NodeErrorKind;
 
-use crate::id::Id;
+use crate::blob::{tree::TreeId, DataId};
 
 #[derive(
     Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Constructor, PartialOrd, Ord,
@@ -53,14 +53,14 @@ pub struct Node {
     /// # Note
     ///
     /// This should be only set for regular files.
-    pub content: Option<Vec<Id>>,
+    pub content: Option<Vec<DataId>>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     /// Subtree of the Node.
     ///
     /// # Note
     ///
     /// This should be only set for directories. (TODO: Check if this is correct)
-    pub subtree: Option<Id>,
+    pub subtree: Option<TreeId>,
 }
 
 #[serde_as]

crates/core/src/blob.rs

@@ -5,7 +5,7 @@
 use enum_map::{Enum, EnumMap};
 use serde_derive::{Deserialize, Serialize};
 
-use crate::id::Id;
+use crate::new_id;
 
 /// All [`BlobType`]s which are supported by the repository
 pub const ALL_BLOB_TYPES: [BlobType; 2] = [BlobType::Tree, BlobType::Data];
@@ -66,17 +66,46 @@
     }
 }
 
+new_id!(BlobId, "blob");
+
+pub trait PackedId: Copy + Into<BlobId> + From<BlobId> {
+    const TYPE: BlobType;
+}
+
+#[macro_export]
+/// Generate newtypes for `Id`s identifying packed blobs
+macro_rules! new_blobid {
+    ($a:ident, $b: expr) => {
+        $crate::new_id!($a, concat!("blob of type", stringify!($b)));
+        impl From<$crate::blob::BlobId> for $a {
+            fn from(id: $crate::blob::BlobId) -> Self {
+                (*id).into()
+            }
+        }
+        impl From<$a> for $crate::blob::BlobId {
+            fn from(id: $a) -> Self {
+                (*id).into()
+            }
+        }
+        impl $crate::blob::PackedId for $a {
+            const TYPE: $crate::blob::BlobType = $b;
+        }
+    };
+}
+
+new_blobid!(DataId, BlobType::Data);
+
 /// A `Blob` is a file that is stored in the backend.
 ///
 /// It can be a `tree` or a `data` blob.
 ///
 /// A `tree` blob is a file that contains a list of other blobs.
 /// A `data` blob is a file that contains the actual data.
-#[derive(Debug, PartialEq, Eq, Clone, Constructor)]
-pub(crate) struct Blob {
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Constructor)]
+pub struct Blob {
     /// The type of the blob
     tpe: BlobType,
 
     /// The id of the blob
-    id: Id,
+    id: BlobId,
 }