From 1962cdaebc71bec28861635784e0b41deac98060 Mon Sep 17 00:00:00 2001
From: Lars Wirzenius <liw@liw.fi>
Date: Sun, 1 Aug 2021 20:50:58 +0300
Subject: refactor: use a struct for GenId

This means a ChunkId can't be used instead.

Sponsored-by: author
---
 src/client.rs      |  4 ++--
 src/cmd/resolve.rs |  4 ++--
 src/cmd/restore.rs |  2 +-
 src/generation.rs  | 33 ++++++++++++++++++++++++++++-----
 src/genlist.rs     |  6 +++---
 5 files changed, 36 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/client.rs b/src/client.rs
index b866471..c655bb2 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -102,7 +102,7 @@ impl AsyncBackupClient {
     }
 
     async fn fetch_generation_chunk(&self, gen_id: &GenId) -> Result<GenerationChunk, ClientError> {
-        let chunk = self.fetch_chunk(gen_id).await?;
+        let chunk = self.fetch_chunk(gen_id.as_chunk_id()).await?;
         let gen = GenerationChunk::from_data_chunk(&chunk)?;
         Ok(gen)
     }
@@ -323,7 +323,7 @@ impl BackupClient {
     }
 
     fn fetch_generation_chunk(&self, gen_id: &GenId) -> Result<GenerationChunk, ClientError> {
-        let chunk = self.fetch_chunk(gen_id)?;
+        let chunk = self.fetch_chunk(gen_id.as_chunk_id())?;
         let gen = GenerationChunk::from_data_chunk(&chunk)?;
         Ok(gen)
     }
diff --git a/src/cmd/resolve.rs b/src/cmd/resolve.rs
index a175655..9b36445 100644
--- a/src/cmd/resolve.rs
+++ b/src/cmd/resolve.rs
@@ -23,8 +23,8 @@ impl Resolve {
             Err(err) => {
                 return Err(err.into());
             }
-            Ok(old_id) => {
-                println!("{}", old_id);
+            Ok(gen_id) => {
+                println!("{}", gen_id.as_chunk_id());
             }
         };
 
diff --git a/src/cmd/restore.rs b/src/cmd/restore.rs
index 8d05481..e03f3de 100644
--- a/src/cmd/restore.rs
+++ b/src/cmd/restore.rs
@@ -41,7 +41,7 @@ impl Restore {
 
         let genlist = client.list_generations().await?;
         let gen_id = genlist.resolve(&self.gen_id)?;
-        info!("generation id is {}", gen_id);
+        info!("generation id is {}", gen_id.as_chunk_id());
 
         let gen = client.fetch_generation(&gen_id, temp.path()).await?;
         info!("restoring {} files", gen.file_count()?);
diff --git a/src/generation.rs b/src/generation.rs
index 66b4647..5412ae7 100644
--- a/src/generation.rs
+++ b/src/generation.rs
@@ -4,13 +4,36 @@ use crate::chunkid::ChunkId;
 use crate::fsentry::FilesystemEntry;
 use log::debug;
 use rusqlite::Connection;
+use std::fmt;
 use std::path::{Path, PathBuf};
 
 /// An identifier for a file in a generation.
 type FileId = i64;
 
 /// An identifier for a generation.
-pub type GenId = ChunkId;
+#[derive(Debug, Clone)]
+pub struct GenId {
+    id: ChunkId,
+}
+
+impl GenId {
+    pub fn from_chunk_id(id: ChunkId) -> Self {
+        Self { id }
+    }
+
+    pub fn as_chunk_id(&self) -> &ChunkId {
+        &self.id
+    }
+}
+
+impl fmt::Display for GenId {
+    /// Format an identifier for display.
+    ///
+    /// The output can be parsed to re-created an identical identifier.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.id)
+    }
+}
 
 /// A nascent backup generation.
 ///
@@ -100,21 +123,21 @@ impl NascentGeneration {
 /// A generation is finished when it's on the server. It can be restored.
 #[derive(Debug, Clone)]
 pub struct FinishedGeneration {
-    id: ChunkId,
+    id: GenId,
     ended: String,
 }
 
 impl FinishedGeneration {
     pub fn new(id: &str, ended: &str) -> Self {
-        let id = id.parse().unwrap(); // this never fails
+        let id = GenId::from_chunk_id(id.parse().unwrap()); // this never fails
         Self {
             id,
             ended: ended.to_string(),
         }
     }
 
-    pub fn id(&self) -> ChunkId {
-        self.id.clone()
+    pub fn id(&self) -> &GenId {
+        &self.id
     }
 
     pub fn ended(&self) -> &str {
diff --git a/src/genlist.rs b/src/genlist.rs
index edc405a..a81a997 100644
--- a/src/genlist.rs
+++ b/src/genlist.rs
@@ -29,10 +29,10 @@ impl GenerationList {
             let i = self.list.len() - 1;
             Some(self.list[i].clone())
         } else {
-            let genref: ChunkId = genref.parse().unwrap();
+            let genref = GenId::from_chunk_id(genref.parse().unwrap());
             let hits: Vec<FinishedGeneration> = self
                 .iter()
-                .filter(|gen| gen.id() == genref)
+                .filter(|gen| gen.id().as_chunk_id() == genref.as_chunk_id())
                 .cloned()
                 .collect();
             if hits.len() == 1 {
@@ -45,7 +45,7 @@ impl GenerationList {
             None => Err(GenerationListError::UnknownGeneration(ChunkId::recreate(
                 genref,
             ))),
-            Some(gen) => Ok(gen.id()),
+            Some(gen) => Ok(gen.id().clone()),
         }
     }
 }
-- 
cgit v1.2.1