restore original representation of `Tag` at the cost of some duplication

That way both representations are optimal in memory for their intended usecase. - `TagRef` is decodable from a buffer refers to it with all of its fields. That way round-trips are cheapest. - `Tag` does not allocate for hashes as there is a more compact representation: `git_hash::ObjectId`.

Sebastian Thiel committed 3 years ago

Commit dd0a23d1 parent 7242d1f6 files · +49 −59Browse files

Showing the changes to git-object/src (5 of 6 files). Show all

Unified · Split

5 files

git-object/src/commit/write.rs +8 −8
git-object/src/lib.rs +3 −4
git-object/src/object/convert.rs +4 −25
git-object/src/tag/mod.rs +1 −9
git-object/src/tag/write.rs +30 −6

git-object/src/commit/write.rs+8−8

         out.write_all(&self.message)
     }
+    fn kind(&self) -> Kind {
+        Kind::Commit
+    }
     fn size(&self) -> usize {
         let hash_in_hex = self.tree.kind().len_in_hex();
         b"tree".len() + 1 /*space*/ + hash_in_hex + 1 /* nl */
             + 1 /* nl */
             + self.message.len()
     }
-    fn kind(&self) -> Kind {
-        Kind::Commit
-    }
 }
 impl<'a> crate::WriteTo for CommitRef<'a> {
         out.write_all(self.message)
     }
+    fn kind(&self) -> Kind {
+        Kind::Commit
+    }
     fn size(&self) -> usize {
         let hash_in_hex = self.tree().kind().len_in_hex();
         b"tree".len() + 1 /* space */ + hash_in_hex + 1 /* nl */
             + 1 /* nl */
             + self.message.len()
     }
-    fn kind(&self) -> Kind {
-        Kind::Commit
-    }
 }

git-object/src/lib.rs+3−4

     #[cfg_attr(feature = "serde1", serde(borrow))]
     pub target: &'a BStr,
     /// The kind of object that `target` points to.
-    pub target_kind: crate::Kind,
+    pub target_kind: Kind,
     /// The name of the tag, e.g. "v1.0".
     pub name: &'a BStr,
     /// The author of the tag.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Tag {
-    /// The hash this tag is pointing to stored as hexadecimal representation from which an `ObjectId`
+    /// The hash this tag is pointing to.
-    /// can be constructed. Use [`.target()`][Tag::target()] to access that `ObjectId`.
+    pub target: git_hash::ObjectId,
-    pub target: BString,
     /// The kind of object this tag is pointing to.
     pub target_kind: Kind,
     /// The name of the tag, e.g. "v1.0".

git-object/src/object/convert.rs+4−25

 use std::convert::TryFrom;
-use crate::{bstr::BStr, tree, Blob, BlobRef, Commit, CommitRef, Object, ObjectRef, Tag, TagRef, Tree, TreeRef};
+use crate::{tree, Blob, BlobRef, Commit, CommitRef, Object, ObjectRef, Tag, TagRef, Tree, TreeRef};
 impl From<TagRef<'_>> for Tag {
     fn from(other: TagRef<'_>) -> Tag {
             pgp_signature,
         } = other;
         Tag {
-            target: target.to_owned(),
+            target: git_hash::ObjectId::from_hex(target).expect("prior parser validation"),
             name: name.to_owned(),
             target_kind,
             message: message.to_owned(),
     }
 }
-impl<'a> From<&'a Tag> for TagRef<'a> {
-    fn from(other: &'a Tag) -> TagRef<'a> {
-        let Tag {
-            target,
-            target_kind,
-            name,
-            tagger,
-            message,
-            pgp_signature,
-        } = other;
-        TagRef {
-            target: target.as_ref(),
-            target_kind: *target_kind,
-            name: name.as_ref(),
-            tagger: tagger.as_ref().map(|s| s.to_ref()),
-            message: message.as_ref(),
-            pgp_signature: pgp_signature.as_deref().map(BStr::new),
-        }
-    }
-}
 impl From<CommitRef<'_>> for Commit {
     fn from(other: CommitRef<'_>) -> Commit {
         let CommitRef {
             extra_headers,
         } = other;
         Commit {
-            tree: git_hash::ObjectId::from_hex(tree).expect("40 bytes hex sha1"),
+            tree: git_hash::ObjectId::from_hex(tree).expect("prior parser validation"),
             parents: parents
                 .iter()
-                .map(|parent| git_hash::ObjectId::from_hex(parent).expect("40 bytes hex sha1"))
+                .map(|parent| git_hash::ObjectId::from_hex(parent).expect("prior parser validation"))
                 .collect(),
             author: author.into(),
             committer: committer.into(),

git-object/src/tag/mod.rs+1−9

@@ -1,4 +1,4 @@
1	use crate::{Tag, TagRef};	1	use crate::TagRef;
2		2
3	mod decode;	3	mod decode;
4		4
@@ -20,11 +20,3 @@ impl<'a> TagRef<'a> { · 15 unmodified lines
20	git_hash::ObjectId::from_hex(self.target).expect("prior validation")	20	git_hash::ObjectId::from_hex(self.target).expect("prior validation")
21	}	21	}
22	}	22	}
23
24	/// Access
25	impl Tag {
26	/// The hash this tag is pointing to.
27	pub fn target(&self) -> git_hash::ObjectId {
28	git_hash::ObjectId::from_hex(&self.target).expect("parser assured this is a valid hash")
29	}
30	}

git-object/src/tag/write.rs+30−6

@@ -21,22 +21,46 @@ impl From<Error> for io::Error { · 20 unmodified lines
21	}	21	}
22		22
23	impl crate::WriteTo for Tag {	23	impl crate::WriteTo for Tag {
24	fn write_to(&self, out: impl io::Write) -> io::Result<()> {	24	fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
25	TagRef::from(self).write_to(out)	25	encode::trusted_header_id(b"object", &self.target, &mut out)?;
26	}	26	encode::trusted_header_field(b"type", self.target_kind.as_bytes(), &mut out)?;
		27	encode::header_field(b"tag", validated_name(self.name.as_ref())?, &mut out)?;
		28	if let Some(tagger) = &self.tagger {
		29	encode::trusted_header_signature(b"tagger", &tagger.to_ref(), &mut out)?;
		30	}
27		31
28	fn size(&self) -> usize {	32	out.write_all(NL)?;
29	TagRef::from(self).size()	33	if !self.message.is_empty() {
		34	out.write_all(self.message.as_ref())?;
		35	}
		36	if let Some(message) = &self.pgp_signature {
		37	out.write_all(NL)?;
		38	out.write_all(message.as_ref())?;
		39	}
		40	Ok(())
30	}	41	}
31		42
32	fn kind(&self) -> Kind {	43	fn kind(&self) -> Kind {
33	Kind::Tag	44	Kind::Tag
34	}	45	}
		46
		47	fn size(&self) -> usize {
		48	b"object".len() + 1 /* space / + self.target.kind().len_in_hex() + 1 / nl */
		49	+ b"type".len() + 1 /* space / + self.target_kind.as_bytes().len() + 1 / nl */
		50	+ b"tag".len() + 1 /* space / + self.name.len() + 1 / nl */
		51	+ self
		52	.tagger
		53	.as_ref()
		54	.map(\|t\| b"tagger".len() + 1 /* space / + t.size() + 1 / nl */)
		55	.unwrap_or(0)
		56	+ 1 /* nl */ + self.message.len()
		57	+ self.pgp_signature.as_ref().map(\|m\| 1 /* nl */ + m.len()).unwrap_or(0)
		58	}
35	}	59	}
36		60
37	impl<'a> crate::WriteTo for TagRef<'a> {	61	impl<'a> crate::WriteTo for TagRef<'a> {
38	fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {	62	fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
39	encode::trusted_header_id(b"object", &self.target(), &mut out)?;	63	encode::trusted_header_field(b"object", &self.target, &mut out)?;
40	encode::trusted_header_field(b"type", self.target_kind.as_bytes(), &mut out)?;	64	encode::trusted_header_field(b"type", self.target_kind.as_bytes(), &mut out)?;
41	encode::header_field(b"tag", validated_name(self.name)?, &mut out)?;	65	encode::header_field(b"tag", validated_name(self.name)?, &mut out)?;
42	if let Some(tagger) = &self.tagger {	66	if let Some(tagger) = &self.tagger {

restore original representation of `Tag` at the cost of some duplication

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code