gix_pack/data/entry/header.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
use std::io;
use super::{BLOB, COMMIT, OFS_DELTA, REF_DELTA, TAG, TREE};
use crate::data;
/// The header portion of a pack data entry, identifying the kind of stored object.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[allow(missing_docs)]
pub enum Header {
/// The object is a commit
Commit,
/// The object is a tree
Tree,
/// The object is a blob
Blob,
/// The object is a tag
Tag,
/// Describes a delta-object which needs to be applied to a base. The base object is identified by the `base_id` field
/// which is found within the parent repository.
/// Most commonly used for **thin-packs** when receiving pack files from the server to refer to objects that are not
/// part of the pack but expected to be present in the receivers repository.
///
/// # Note
/// This could also be an object within this pack if the LSB encoded offset would be larger than 20 bytes, which is unlikely to
/// happen.
///
/// **The naming** is exactly the same as the canonical implementation uses, namely **REF_DELTA**.
RefDelta { base_id: gix_hash::ObjectId },
/// Describes a delta-object present in this pack which acts as base for this object.
/// The base object is measured as a distance from this objects
/// pack offset, so that `base_pack_offset = this_objects_pack_offset - base_distance`
///
/// # Note
///
/// **The naming** is exactly the same as the canonical implementation uses, namely **OFS_DELTA**.
OfsDelta { base_distance: u64 },
}
impl Header {
/// Subtract `distance` from `pack_offset` safely without the chance for overflow or no-ops if `distance` is 0.
pub fn verified_base_pack_offset(pack_offset: data::Offset, distance: u64) -> Option<data::Offset> {
if distance == 0 {
return None;
}
pack_offset.checked_sub(distance)
}
/// Convert the header's object kind into [`gix_object::Kind`] if possible
pub fn as_kind(&self) -> Option<gix_object::Kind> {
use gix_object::Kind::*;
Some(match self {
Header::Tree => Tree,
Header::Blob => Blob,
Header::Commit => Commit,
Header::Tag => Tag,
Header::RefDelta { .. } | Header::OfsDelta { .. } => return None,
})
}
/// Convert this header's object kind into the packs internal representation
pub fn as_type_id(&self) -> u8 {
use Header::*;
match self {
Blob => BLOB,
Tree => TREE,
Commit => COMMIT,
Tag => TAG,
OfsDelta { .. } => OFS_DELTA,
RefDelta { .. } => REF_DELTA,
}
}
/// Return's true if this is a delta object, i.e. not a full object.
pub fn is_delta(&self) -> bool {
matches!(self, Header::OfsDelta { .. } | Header::RefDelta { .. })
}
/// Return's true if this is a base object, i.e. not a delta object.
pub fn is_base(&self) -> bool {
!self.is_delta()
}
}
impl Header {
/// Encode this header along the given `decompressed_size_in_bytes` into the `out` write stream for use within a data pack.
///
/// Returns the amount of bytes written to `out`.
/// `decompressed_size_in_bytes` is the full size in bytes of the object that this header represents
pub fn write_to(&self, decompressed_size_in_bytes: u64, out: &mut dyn io::Write) -> io::Result<usize> {
let mut size = decompressed_size_in_bytes;
let mut written = 1;
let mut c: u8 = (self.as_type_id() << 4) | (size as u8 & 0b0000_1111);
size >>= 4;
while size != 0 {
out.write_all(&[c | 0b1000_0000])?;
written += 1;
c = size as u8 & 0b0111_1111;
size >>= 7;
}
out.write_all(&[c])?;
use Header::*;
match self {
RefDelta { base_id: oid } => {
out.write_all(oid.as_slice())?;
written += oid.as_slice().len();
}
OfsDelta { base_distance } => {
let mut buf = [0u8; 10];
let buf = leb64_encode(*base_distance, &mut buf);
out.write_all(buf)?;
written += buf.len();
}
Blob | Tree | Commit | Tag => {}
}
Ok(written)
}
/// The size of the header in bytes when serialized
pub fn size(&self, decompressed_size: u64) -> usize {
self.write_to(decompressed_size, &mut io::sink())
.expect("io::sink() to never fail")
}
}
#[inline]
fn leb64_encode(mut n: u64, buf: &mut [u8; 10]) -> &[u8] {
let mut bytes_written = 1;
buf[buf.len() - 1] = n as u8 & 0b0111_1111;
for out in buf.iter_mut().rev().skip(1) {
n >>= 7;
if n == 0 {
break;
}
n -= 1;
*out = 0b1000_0000 | (n as u8 & 0b0111_1111);
bytes_written += 1;
}
debug_assert_eq!(n, 0, "BUG: buffer must be large enough to hold a 64 bit integer");
&buf[buf.len() - bytes_written..]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn leb64_encode_max_int() {
let mut buf = [0u8; 10];
let buf = leb64_encode(u64::MAX, &mut buf);
assert_eq!(buf.len(), 10, "10 bytes should be used when 64bits are encoded");
}
}