Make the accessors on TempTag return copies, not references.

For consistency.

Author: rklaehn

examples/expiring-tags.rs

@@ -162,14 +162,14 @@ async fn main() -> anyhow::Result<()> {
         let expires_at = SystemTime::now()
             .checked_add(Duration::from_secs(10))
             .unwrap();
-        create_expiring_tag(&store, &[*a.hash(), *b.hash()], "expiring", expires_at).await?;
+        create_expiring_tag(&store, &[a.hash(), b.hash()], "expiring", expires_at).await?;
 
         // add a single blob and tag it with an expiry date 60 seconds in the future
         let c = batch.add_bytes("blob 3".as_bytes()).await?;
         let expires_at = SystemTime::now()
             .checked_add(Duration::from_secs(60))
             .unwrap();
-        create_expiring_tag(&store, &[*c.hash()], "expiring", expires_at).await?;
+        create_expiring_tag(&store, &[c.hash()], "expiring", expires_at).await?;
         // batch goes out of scope, so data is only protected by the tags we created
     }
 

examples/transfer-collection.rs

@@ -80,14 +80,14 @@ impl Node {
 
         let collection_items = collection_items
             .iter()
-            .map(|(name, tag)| (name.to_string(), *tag.hash()))
+            .map(|(name, tag)| (name.to_string(), tag.hash()))
             .collect::<Vec<_>>();
 
         let collection = Collection::from_iter(collection_items);
 
         let tt = collection.store(&self.store).await?;
-        self.store.tags().create(*tt.hash_and_format()).await?;
-        Ok(*tt.hash())
+        self.store.tags().create(tt.hash_and_format()).await?;
+        Ok(tt.hash())
     }
 
     /// retrieve an entire collection from a given hash and provider

src/api/blobs.rs

@@ -656,20 +656,20 @@ impl<'a> AddProgress<'a> {
     pub async fn with_named_tag(self, name: impl AsRef<[u8]>) -> RequestResult<HashAndFormat> {
         let blobs = self.blobs.clone();
         let tt = self.temp_tag().await?;
-        let haf = *tt.hash_and_format();
+        let haf = tt.hash_and_format();
         let tags = Tags::ref_from_sender(&blobs.client);
-        tags.set(name, *tt.hash_and_format()).await?;
+        tags.set(name, haf).await?;
         drop(tt);
         Ok(haf)
     }
 
     pub async fn with_tag(self) -> RequestResult<TagInfo> {
         let blobs = self.blobs.clone();
         let tt = self.temp_tag().await?;
-        let hash = *tt.hash();
+        let hash = tt.hash();
         let format = tt.format();
         let tags = Tags::ref_from_sender(&blobs.client);
-        let name = tags.create(*tt.hash_and_format()).await?;
+        let name = tags.create(tt.hash_and_format()).await?;
         drop(tt);
         Ok(TagInfo { name, hash, format })
     }

src/api/remote.rs

@@ -1088,7 +1088,7 @@ mod tests {
         let store = FsStore::load(td.path().join("blobs.db")).await?;
         let blobs = store.blobs();
         let tt = blobs.add_slice(b"test").temp_tag().await?;
-        let hash = *tt.hash();
+        let hash = tt.hash();
         let info = store.remote().local(hash).await?;
         assert_eq!(info.bitfield.ranges, ChunkRanges::all());
         assert_eq!(info.local_bytes(), 4);

src/format/collection.rs

@@ -191,7 +191,7 @@ impl Collection {
         let (links, meta) = self.into_parts();
         let meta_bytes = postcard::to_stdvec(&meta)?;
         let meta_tag = db.add_bytes(meta_bytes).temp_tag().await?;
-        let links_bytes = std::iter::once(*meta_tag.hash())
+        let links_bytes = std::iter::once(meta_tag.hash())
             .chain(links)
             .collect::<HashSeq>();
         let links_tag = db

src/store/fs.rs

@@ -1602,7 +1602,7 @@ pub mod tests {
             let stream = bytes_to_stream(expected.clone(), 1023);
             let obs = store.observe(expected_hash);
             let tt = store.add_stream(stream).await.temp_tag().await?;
-            assert_eq!(expected_hash, *tt.hash());
+            assert_eq!(expected_hash, tt.hash());
             // we must at some point see completion, otherwise the test will hang
             obs.await_completion().await?;
             let actual = store.get_bytes(expected_hash).await?;
@@ -2043,8 +2043,8 @@ pub mod tests {
             .await?
             .collect::<HashSet<_>>()
             .await;
-        assert!(tts.contains(tt1.hash_and_format()));
-        assert!(tts.contains(tt2.hash_and_format()));
+        assert!(tts.contains(&tt1.hash_and_format()));
+        assert!(tts.contains(&tt2.hash_and_format()));
         drop(batch);
         store.sync_db().await?;
         store.wait_idle().await?;
@@ -2055,8 +2055,8 @@ pub mod tests {
             .collect::<HashSet<_>>()
             .await;
         // temp tag went out of scope, so it does not work anymore
-        assert!(!tts.contains(tt1.hash_and_format()));
-        assert!(!tts.contains(tt2.hash_and_format()));
+        assert!(!tts.contains(&tt1.hash_and_format()));
+        assert!(!tts.contains(&tt2.hash_and_format()));
         drop(tt1);
         drop(tt2);
         Ok(())
@@ -2089,29 +2089,29 @@ pub mod tests {
             let data = vec![0u8; size];
             let data = Bytes::from(data);
             let tt = store.add_bytes(data.clone()).temp_tag().await?;
-            data_by_hash.insert(*tt.hash(), data);
+            data_by_hash.insert(tt.hash(), data);
             hashes.push(tt);
         }
         store.sync_db().await?;
         for tt in &hashes {
-            let hash = *tt.hash();
+            let hash = tt.hash();
             let path = testdir.path().join(format!("{hash}.txt"));
             store.export(hash, path).await?;
         }
         for tt in &hashes {
             let hash = tt.hash();
             let data = store
-                .export_bao(*hash, ChunkRanges::all())
+                .export_bao(hash, ChunkRanges::all())
                 .data_to_vec()
                 .await
                 .unwrap();
-            assert_eq!(data, data_by_hash[hash].to_vec());
+            assert_eq!(data, data_by_hash[&hash].to_vec());
             let bao = store
-                .export_bao(*hash, ChunkRanges::all())
+                .export_bao(hash, ChunkRanges::all())
                 .bao_to_vec()
                 .await
                 .unwrap();
-            bao_by_hash.insert(*hash, bao);
+            bao_by_hash.insert(hash, bao);
         }
         store.dump().await?;
 

src/store/gc.rs

@@ -263,15 +263,15 @@ mod tests {
         let ft = blobs.add_slice("f").temp_tag().await?;
         let gt = blobs.add_slice("g").temp_tag().await?;
         let ht = blobs.add_slice("h").with_named_tag("h").await?;
-        let a = *at.hash();
-        let b = *bt.hash();
-        let c = *ct.hash();
-        let d = *dt.hash();
-        let e = *et.hash();
-        let f = *ft.hash();
-        let g = *gt.hash();
+        let a = at.hash();
+        let b = bt.hash();
+        let c = ct.hash();
+        let d = dt.hash();
+        let e = et.hash();
+        let f = ft.hash();
+        let g = gt.hash();
         let h = ht.hash;
-        store.tags().set("c", *ct.hash_and_format()).await?;
+        store.tags().set("c", ct.hash_and_format()).await?;
         let dehs = [d, e].into_iter().collect::<HashSeq>();
         let hehs = blobs
             .add_bytes_with_opts(AddBytesOptions {
@@ -287,7 +287,7 @@ mod tests {
             })
             .temp_tag()
             .await?;
-        store.tags().set("fg", *fghs.hash_and_format()).await?;
+        store.tags().set("fg", fghs.hash_and_format()).await?;
         drop(fghs);
         drop(bt);
         store.tags().delete("h").await?;
@@ -335,11 +335,11 @@ mod tests {
                 .temp_tag()
                 .await?;
             let ah = a.hash();
-            let data_path = options.data_path(ah);
-            let outboard_path = options.outboard_path(ah);
+            let data_path = options.data_path(&ah);
+            let outboard_path = options.outboard_path(&ah);
             assert!(data_path.exists());
             assert!(outboard_path.exists());
-            assert!(store.has(*ah).await?);
+            assert!(store.has(ah).await?);
             drop(a);
             gc_run_once(store, &mut live).await?;
             assert!(!data_path.exists());
@@ -410,7 +410,7 @@ mod tests {
 
     async fn gc_check_deletion(store: &Store) -> TestResult {
         let temp_tag = store.add_bytes(b"foo".to_vec()).temp_tag().await?;
-        let hash = *temp_tag.hash();
+        let hash = temp_tag.hash();
         assert_eq!(store.get_bytes(hash).await?.as_ref(), b"foo");
         drop(temp_tag);
         let mut live = HashSet::new();

src/store/mem.rs

@@ -1087,7 +1087,7 @@ mod tests {
     async fn smoke() -> TestResult<()> {
         let store = MemStore::new();
         let tt = store.add_bytes(vec![0u8; 1024 * 64]).temp_tag().await?;
-        let hash = *tt.hash();
+        let hash = tt.hash();
         println!("hash: {hash:?}");
         let mut stream = store.export_bao(hash, ChunkRanges::all()).stream();
         while let Some(item) = stream.next().await {

src/tests.rs

@@ -435,7 +435,7 @@ pub async fn add_test_hash_seq(
     for size in sizes {
         tts.push(batch.add_bytes(test_data(size)).await?);
     }
-    let hash_seq = tts.iter().map(|tt| *tt.hash()).collect::<HashSeq>();
+    let hash_seq = tts.iter().map(|tt| tt.hash()).collect::<HashSeq>();
     let root = batch
         .add_bytes_with_opts((hash_seq, BlobFormat::HashSeq))
         .with_named_tag("hs")
@@ -461,7 +461,7 @@ pub async fn add_test_hash_seq_incomplete(
             blobs.import_bao_bytes(hash, ranges, bao).await?;
         }
     }
-    let hash_seq = tts.iter().map(|tt| *tt.hash()).collect::<HashSeq>();
+    let hash_seq = tts.iter().map(|tt| tt.hash()).collect::<HashSeq>();
     let hash_seq_bytes = Bytes::from(hash_seq);
     let ranges = present(0);
     let (root, bao) = create_n0_bao(&hash_seq_bytes, &ranges)?;
@@ -673,7 +673,7 @@ async fn node_smoke_mem() -> TestResult<()> {
 
 async fn node_smoke(store: &Store) -> TestResult<()> {
     let tt = store.add_bytes(b"hello world".to_vec()).temp_tag().await?;
-    let hash = *tt.hash();
+    let hash = tt.hash();
     let endpoint = Endpoint::builder().discovery_n0().bind().await?;
     let blobs = crate::net_protocol::BlobsProtocol::new(store, None);
     let r1 = Router::builder(endpoint)
@@ -701,7 +701,7 @@ async fn test_export_chunk() -> TestResult {
     for size in [1024 * 18 + 1] {
         let data = vec![0u8; size];
         let tt = store.add_slice(&data).temp_tag().await?;
-        let hash = *tt.hash();
+        let hash = tt.hash();
         let c = blobs.export_chunk(hash, 0).await;
         println!("{c:?}");
         let c = blobs.export_chunk(hash, 1000000).await;

src/util/temp_tag.rs

@@ -98,13 +98,8 @@ impl TempTag {
     }
 
     /// The hash of the pinned item
-    pub fn inner(&self) -> &HashAndFormat {
-        &self.inner
-    }
-
-    /// The hash of the pinned item
-    pub fn hash(&self) -> &Hash {
-        &self.inner.hash
+    pub fn hash(&self) -> Hash {
+        self.inner.hash
     }
 
     /// The format of the pinned item
@@ -113,8 +108,8 @@ impl TempTag {
     }
 
     /// The hash and format of the pinned item
-    pub fn hash_and_format(&self) -> &HashAndFormat {
-        &self.inner
+    pub fn hash_and_format(&self) -> HashAndFormat {
+        self.inner
     }
 
     /// Keep the item alive until the end of the process