use std::{
borrow::Borrow,
hash::{Hash, Hasher},
ops::Deref,
};
use crate::{borrowed::oid, Kind, SIZE_OF_SHA1_DIGEST};
#[derive(PartialEq, Eq, Ord, PartialOrd, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ObjectId {
Sha1([u8; SIZE_OF_SHA1_DIGEST]),
}
#[allow(clippy::derived_hash_with_manual_eq)]
impl Hash for ObjectId {
fn hash<H: Hasher>(&self, state: &mut H) {
state.write(self.as_slice())
}
}
#[allow(missing_docs)]
pub mod decode {
use std::str::FromStr;
use crate::object_id::ObjectId;
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error("A hash sized {0} hexadecimal characters is invalid")]
InvalidHexEncodingLength(usize),
#[error("Invalid character encountered")]
Invalid,
}
impl ObjectId {
pub fn from_hex(buffer: &[u8]) -> Result<ObjectId, Error> {
match buffer.len() {
40 => Ok({
ObjectId::Sha1({
let mut buf = [0; 20];
faster_hex::hex_decode(buffer, &mut buf).map_err(|err| match err {
faster_hex::Error::InvalidChar | faster_hex::Error::Overflow => Error::Invalid,
faster_hex::Error::InvalidLength(_) => {
unreachable!("BUG: This is already checked")
}
})?;
buf
})
}),
len => Err(Error::InvalidHexEncodingLength(len)),
}
}
}
impl FromStr for ObjectId {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::from_hex(s.as_bytes())
}
}
}
impl ObjectId {
#[inline]
pub fn kind(&self) -> Kind {
match self {
ObjectId::Sha1(_) => Kind::Sha1,
}
}
#[inline]
pub fn as_slice(&self) -> &[u8] {
match self {
Self::Sha1(b) => b.as_ref(),
}
}
#[inline]
pub fn as_mut_slice(&mut self) -> &mut [u8] {
match self {
Self::Sha1(b) => b.as_mut(),
}
}
#[inline]
pub const fn empty_blob(hash: Kind) -> ObjectId {
match hash {
Kind::Sha1 => {
ObjectId::Sha1(*b"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91")
}
}
}
#[inline]
pub const fn empty_tree(hash: Kind) -> ObjectId {
match hash {
Kind::Sha1 => {
ObjectId::Sha1(*b"\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04")
}
}
}
#[inline]
#[doc(alias = "zero", alias = "git2")]
pub const fn null(kind: Kind) -> ObjectId {
match kind {
Kind::Sha1 => Self::null_sha1(),
}
}
#[inline]
#[doc(alias = "is_zero", alias = "git2")]
pub fn is_null(&self) -> bool {
match self {
ObjectId::Sha1(digest) => &digest[..] == oid::null_sha1().as_bytes(),
}
}
#[inline]
pub fn is_empty_blob(&self) -> bool {
self == &Self::empty_blob(self.kind())
}
#[inline]
pub fn is_empty_tree(&self) -> bool {
self == &Self::empty_tree(self.kind())
}
}
impl ObjectId {
pub fn from_bytes_or_panic(bytes: &[u8]) -> Self {
match bytes.len() {
20 => Self::Sha1(bytes.try_into().expect("prior length validation")),
other => panic!("BUG: unsupported hash len: {other}"),
}
}
}
impl ObjectId {
#[inline]
fn new_sha1(id: [u8; SIZE_OF_SHA1_DIGEST]) -> Self {
ObjectId::Sha1(id)
}
#[inline]
pub(crate) fn from_20_bytes(b: &[u8]) -> ObjectId {
let mut id = [0; SIZE_OF_SHA1_DIGEST];
id.copy_from_slice(b);
ObjectId::Sha1(id)
}
#[inline]
pub(crate) const fn null_sha1() -> ObjectId {
ObjectId::Sha1([0u8; 20])
}
}
impl std::fmt::Debug for ObjectId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ObjectId::Sha1(_hash) => f.write_str("Sha1(")?,
}
for b in self.as_bytes() {
write!(f, "{b:02x}")?;
}
f.write_str(")")
}
}
impl From<[u8; SIZE_OF_SHA1_DIGEST]> for ObjectId {
fn from(v: [u8; 20]) -> Self {
Self::new_sha1(v)
}
}
impl From<&oid> for ObjectId {
fn from(v: &oid) -> Self {
match v.kind() {
Kind::Sha1 => ObjectId::from_20_bytes(v.as_bytes()),
}
}
}
impl TryFrom<&[u8]> for ObjectId {
type Error = crate::Error;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
Ok(oid::try_from_bytes(bytes)?.into())
}
}
impl Deref for ObjectId {
type Target = oid;
fn deref(&self) -> &Self::Target {
self.as_ref()
}
}
impl AsRef<oid> for ObjectId {
fn as_ref(&self) -> &oid {
oid::from_bytes_unchecked(self.as_slice())
}
}
impl Borrow<oid> for ObjectId {
fn borrow(&self) -> &oid {
self.as_ref()
}
}
impl std::fmt::Display for ObjectId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.to_hex())
}
}
impl PartialEq<&oid> for ObjectId {
fn eq(&self, other: &&oid) -> bool {
self.as_ref() == *other
}
}