vendor/gix/src/object/impls.rs

   1 use std::convert::TryFrom;
   2
   3 use crate::{object, Commit, Object, ObjectDetached, Tag, Tree};
   4
   5 impl<'repo> From<Object<'repo>> for ObjectDetached {
   6     fn from(mut v: Object<'repo>) -> Self {
   7         ObjectDetached {
   8             id: v.id,
   9             kind: v.kind,
  10             data: std::mem::take(&mut v.data),
  11         }
  12     }
  13 }
  14
  15 impl<'repo> From<Commit<'repo>> for ObjectDetached {
  16     fn from(mut v: Commit<'repo>) -> Self {
  17         ObjectDetached {
  18             id: v.id,
  19             kind: gix_object::Kind::Commit,
  20             data: std::mem::take(&mut v.data),
  21         }
  22     }
  23 }
  24
  25 impl<'repo> From<Tag<'repo>> for ObjectDetached {
  26     fn from(mut v: Tag<'repo>) -> Self {
  27         ObjectDetached {
  28             id: v.id,
  29             kind: gix_object::Kind::Tag,
  30             data: std::mem::take(&mut v.data),
  31         }
  32     }
  33 }
  34
  35 impl<'repo> From<Commit<'repo>> for Object<'repo> {
  36     fn from(mut v: Commit<'repo>) -> Self {
  37         Object {
  38             id: v.id,
  39             kind: gix_object::Kind::Commit,
  40             data: steal_from_freelist(&mut v.data),
  41             repo: v.repo,
  42         }
  43     }
  44 }
  45
  46 impl<'repo> AsRef<[u8]> for Object<'repo> {
  47     fn as_ref(&self) -> &[u8] {
  48         &self.data
  49     }
  50 }
  51
  52 impl AsRef<[u8]> for ObjectDetached {
  53     fn as_ref(&self) -> &[u8] {
  54         &self.data
  55     }
  56 }
  57
  58 impl<'repo> TryFrom<Object<'repo>> for Commit<'repo> {
  59     type Error = Object<'repo>;
  60
  61     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
  62         let handle = value.repo;
  63         match value.kind {
  64             object::Kind::Commit => Ok(Commit {
  65                 id: value.id,
  66                 repo: handle,
  67                 data: steal_from_freelist(&mut value.data),
  68             }),
  69             _ => Err(value),
  70         }
  71     }
  72 }
  73
  74 impl<'repo> TryFrom<Object<'repo>> for Tag<'repo> {
  75     type Error = Object<'repo>;
  76
  77     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
  78         let handle = value.repo;
  79         match value.kind {
  80             object::Kind::Tag => Ok(Tag {
  81                 id: value.id,
  82                 repo: handle,
  83                 data: steal_from_freelist(&mut value.data),
  84             }),
  85             _ => Err(value),
  86         }
  87     }
  88 }
  89
  90 impl<'repo> TryFrom<Object<'repo>> for Tree<'repo> {
  91     type Error = Object<'repo>;
  92
  93     fn try_from(mut value: Object<'repo>) -> Result<Self, Self::Error> {
  94         let handle = value.repo;
  95         match value.kind {
  96             object::Kind::Tree => Ok(Tree {
  97                 id: value.id,
  98                 repo: handle,
  99                 data: steal_from_freelist(&mut value.data),
 100             }),
 101             _ => Err(value),
 102         }
 103     }
 104 }
 105
 106 impl<'r> std::fmt::Debug for Object<'r> {
 107     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 108         use gix_object::Kind::*;
 109         let type_name = match self.kind {
 110             Blob => "Blob",
 111             Commit => "Commit",
 112             Tree => "Tree",
 113             Tag => "Tag",
 114         };
 115         write!(f, "{}({})", type_name, self.id)
 116     }
 117 }
 118
 119 /// In conjunction with the handles free list, leaving an empty Vec in place of the original causes it to not be
 120 /// returned to the free list.
 121 fn steal_from_freelist(data: &mut Vec<u8>) -> Vec<u8> {
 122     std::mem::take(data)
 123 }