gix_object/object/
convert.rs

1use gix_error::{Exn, Message};
2use std::convert::TryFrom;
3
4use crate::parse::parse_signature;
5use crate::{Blob, BlobRef, Commit, CommitRef, Object, ObjectRef, Tag, TagRef, Tree, TreeRef, tree};
6
7impl TryFrom<TagRef<'_>> for Tag {
8    type Error = Exn<Message>;
9
10    fn try_from(other: TagRef<'_>) -> std::result::Result<Tag, Self::Error> {
11        let TagRef {
12            target,
13            name,
14            target_kind,
15            message,
16            tagger,
17            signature,
18        } = other;
19        let untrimmed_tagger = tagger.map(parse_signature).transpose()?.map(Into::into);
20        Ok(Tag {
21            target: gix_hash::ObjectId::from_hex(target).expect("prior parser validation"),
22            name: name.to_owned(),
23            target_kind,
24            message: message.to_owned(),
25            tagger: untrimmed_tagger,
26            signature: signature.map(ToOwned::to_owned),
27        })
28    }
29}
30
31impl TryFrom<CommitRef<'_>> for Commit {
32    type Error = Exn<Message>;
33
34    fn try_from(other: CommitRef<'_>) -> std::result::Result<Commit, Self::Error> {
35        let CommitRef {
36            tree,
37            parents,
38            author,
39            committer,
40            encoding,
41            message,
42            extra_headers,
43        } = other;
44
45        let untrimmed_author = parse_signature(author)?;
46        let untrimmed_committer = parse_signature(committer)?;
47        Ok(Commit {
48            tree: gix_hash::ObjectId::from_hex(tree).expect("prior parser validation"),
49            parents: parents
50                .iter()
51                .map(|parent| gix_hash::ObjectId::from_hex(parent).expect("prior parser validation"))
52                .collect(),
53            author: untrimmed_author.into(),
54            committer: untrimmed_committer.into(),
55            encoding: encoding.map(ToOwned::to_owned),
56            message: message.to_owned(),
57            extra_headers: extra_headers
58                .into_iter()
59                .map(|(k, v)| (k.into(), v.into_owned()))
60                .collect(),
61        })
62    }
63}
64
65impl<'a> From<BlobRef<'a>> for Blob {
66    fn from(v: BlobRef<'a>) -> Self {
67        Blob {
68            data: v.data.to_owned(),
69        }
70    }
71}
72
73impl From<TreeRef<'_>> for Tree {
74    fn from(other: TreeRef<'_>) -> Tree {
75        let TreeRef { entries } = other;
76        Tree {
77            entries: entries.into_iter().map(Into::into).collect(),
78        }
79    }
80}
81
82impl From<tree::EntryRef<'_>> for tree::Entry {
83    fn from(other: tree::EntryRef<'_>) -> tree::Entry {
84        let tree::EntryRef { mode, filename, oid } = other;
85        tree::Entry {
86            mode,
87            filename: filename.to_owned(),
88            oid: oid.into(),
89        }
90    }
91}
92
93impl<'a> From<&'a tree::Entry> for tree::EntryRef<'a> {
94    fn from(other: &'a tree::Entry) -> tree::EntryRef<'a> {
95        let tree::Entry { mode, filename, oid } = other;
96        tree::EntryRef {
97            mode: *mode,
98            filename: filename.as_ref(),
99            oid,
100        }
101    }
102}
103
104impl TryFrom<ObjectRef<'_>> for Object {
105    type Error = Exn<Message>;
106
107    fn try_from(v: ObjectRef<'_>) -> std::result::Result<Self, Self::Error> {
108        Ok(match v {
109            ObjectRef::Tree(v) => Object::Tree(v.into()),
110            ObjectRef::Blob(v) => Object::Blob(v.into()),
111            ObjectRef::Commit(v) => Object::Commit(v.try_into()?),
112            ObjectRef::Tag(v) => Object::Tag(v.try_into()?),
113        })
114    }
115}
116
117impl From<Tag> for Object {
118    fn from(v: Tag) -> Self {
119        Object::Tag(v)
120    }
121}
122
123impl From<Commit> for Object {
124    fn from(v: Commit) -> Self {
125        Object::Commit(v)
126    }
127}
128
129impl From<Tree> for Object {
130    fn from(v: Tree) -> Self {
131        Object::Tree(v)
132    }
133}
134
135impl From<Blob> for Object {
136    fn from(v: Blob) -> Self {
137        Object::Blob(v)
138    }
139}
140
141impl TryFrom<Object> for Tag {
142    type Error = Object;
143
144    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
145        Ok(match value {
146            Object::Tag(v) => v,
147            _ => return Err(value),
148        })
149    }
150}
151
152impl TryFrom<Object> for Commit {
153    type Error = Object;
154
155    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
156        Ok(match value {
157            Object::Commit(v) => v,
158            _ => return Err(value),
159        })
160    }
161}
162
163impl TryFrom<Object> for Tree {
164    type Error = Object;
165
166    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
167        Ok(match value {
168            Object::Tree(v) => v,
169            _ => return Err(value),
170        })
171    }
172}
173
174impl TryFrom<Object> for Blob {
175    type Error = Object;
176
177    fn try_from(value: Object) -> std::result::Result<Self, Self::Error> {
178        Ok(match value {
179            Object::Blob(v) => v,
180            _ => return Err(value),
181        })
182    }
183}
184
185impl<'a> From<TagRef<'a>> for ObjectRef<'a> {
186    fn from(v: TagRef<'a>) -> Self {
187        ObjectRef::Tag(v)
188    }
189}
190
191impl<'a> From<CommitRef<'a>> for ObjectRef<'a> {
192    fn from(v: CommitRef<'a>) -> Self {
193        ObjectRef::Commit(v)
194    }
195}
196
197impl<'a> From<TreeRef<'a>> for ObjectRef<'a> {
198    fn from(v: TreeRef<'a>) -> Self {
199        ObjectRef::Tree(v)
200    }
201}
202
203impl<'a> From<BlobRef<'a>> for ObjectRef<'a> {
204    fn from(v: BlobRef<'a>) -> Self {
205        ObjectRef::Blob(v)
206    }
207}
208
209impl<'a> TryFrom<ObjectRef<'a>> for TagRef<'a> {
210    type Error = ObjectRef<'a>;
211
212    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
213        Ok(match value {
214            ObjectRef::Tag(v) => v,
215            _ => return Err(value),
216        })
217    }
218}
219
220impl<'a> TryFrom<ObjectRef<'a>> for CommitRef<'a> {
221    type Error = ObjectRef<'a>;
222
223    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
224        Ok(match value {
225            ObjectRef::Commit(v) => v,
226            _ => return Err(value),
227        })
228    }
229}
230
231impl<'a> TryFrom<ObjectRef<'a>> for TreeRef<'a> {
232    type Error = ObjectRef<'a>;
233
234    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
235        Ok(match value {
236            ObjectRef::Tree(v) => v,
237            _ => return Err(value),
238        })
239    }
240}
241
242impl<'a> TryFrom<ObjectRef<'a>> for BlobRef<'a> {
243    type Error = ObjectRef<'a>;
244
245    fn try_from(value: ObjectRef<'a>) -> std::result::Result<Self, Self::Error> {
246        Ok(match value {
247            ObjectRef::Blob(v) => v,
248            _ => return Err(value),
249        })
250    }
251}
gix_object/object/convert.rs

gix_object/object/
convert.rs
