use bstr::{BStr, ByteSlice}; use crate::{Commit, CommitRef, TagRef}; mod decode;///pub mod message; /// A parsed commit message that assumes a title separated from the body by two consecutive newlines.////// Titles can have any amount of whitespace#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]pub struct MessageRef<'a> {    /// The title of the commit, as separated from the body with two consecutive newlines. The newlines are not included.    #[cfg_attr(feature = "serde1", serde(borrow))]    pub title: &'a BStr,    /// All bytes not consumed by the title, excluding the separating newlines.    ///    /// The body is `None` if there was now title separation or the body was empty after the separator.    pub body: Option<&'a BStr>,} ///pub mod ref_iter; mod write; impl<'a> CommitRef<'a> {    /// Deserialize a commit from the given `data` bytes while avoiding most allocations.    pub fn from_bytes(data: &'a [u8]) -> Result<CommitRef<'a>, crate::decode::Error> {        decode::commit(data).map(|(_, t)| t).map_err(crate::decode::Error::from)    }    /// Return the `tree` fields hash digest.    pub fn tree(&self) -> git_hash::ObjectId {        git_hash::ObjectId::from_hex(self.tree).expect("prior validation of tree hash during parsing")    }     /// Returns an iterator of parent object ids    pub fn parents(&self) -> impl Iterator<Item = git_hash::ObjectId> + '_ {        self.parents            .iter()            .map(|hex_hash| git_hash::ObjectId::from_hex(hex_hash).expect("prior validation of hashes during parsing"))    }     /// Returns a convenient iterator over all extra headers.    pub fn extra_headers(&self) -> crate::commit::ExtraHeaders<impl Iterator<Item = (&BStr, &BStr)>> {        crate::commit::ExtraHeaders::new(self.extra_headers.iter().map(|(k, v)| (*k, v.as_ref())))    }     /// Return the author, with whitespace trimmed.    ///    /// This is different from the `author` field which may contain whitespace.    pub fn author(&self) -> git_actor::SignatureRef<'a> {        self.author.trim()    }     /// Return the committer, with whitespace trimmed.    ///    /// This is different from the `committer` field which may contain whitespace.    pub fn committer(&self) -> git_actor::SignatureRef<'a> {        self.committer.trim()    }     /// Returns a partially parsed message from which more information can be derived.    pub fn message(&self) -> MessageRef<'a> {        MessageRef::from_bytes(self.message)    }     /// Returns the time at which this commit was created.    pub fn time(&self) -> git_actor::Time {        self.committer.time    }} impl Commit {    /// Returns a convenient iterator over all extra headers.    pub fn extra_headers(&self) -> ExtraHeaders<impl Iterator<Item = (&BStr, &BStr)>> {        ExtraHeaders::new(self.extra_headers.iter().map(|(k, v)| (k.as_bstr(), v.as_bstr())))    }} /// An iterator over extra headers in [owned][crate::Commit] and [borrowed][crate::CommitRef] commits.pub struct ExtraHeaders<I> {    inner: I,} /// Instantiation and convenience.impl<'a, I> ExtraHeaders<I>where    I: Iterator<Item = (&'a BStr, &'a BStr)>,{    /// Create a new instance from an iterator over tuples of (name, value) pairs.    pub fn new(iter: I) -> Self {        ExtraHeaders { inner: iter }    }    /// Find the _value_ of the _first_ header with the given `name`.    pub fn find(mut self, name: &str) -> Option<&'a BStr> {        self.inner            .find_map(move |(k, v)| if k == name.as_bytes().as_bstr() { Some(v) } else { None })    }    /// Return an iterator over all _values_ of headers with the given `name`.    pub fn find_all(self, name: &'a str) -> impl Iterator<Item = &'a BStr> {        self.inner            .filter_map(move |(k, v)| if k == name.as_bytes().as_bstr() { Some(v) } else { None })    }    /// Return an iterator over all git mergetags.    ///    /// A merge tag is a tag object embedded within the respective header field of a commit, making    /// it a child object of sorts.    pub fn mergetags(self) -> impl Iterator<Item = Result<TagRef<'a>, crate::decode::Error>> {        self.find_all("mergetag").map(|b| TagRef::from_bytes(b))    }     /// Return the cryptographic signature provided by gpg/pgp verbatim.    pub fn pgp_signature(self) -> Option<&'a BStr> {        self.find("gpgsig")    }}