use crate::loose; /// An object within an object database with loose or entirely borrowed objects.#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]#[allow(missing_docs)]pub enum Object<'a> {    Loose(loose::Object),    Borrowed(crate::borrowed::Object<'a>),} /// Accessimpl<'a> Object<'a> {    /// Returns the object [`kind`][`git_object::Kind`]    pub fn kind(&self) -> git_object::Kind {        match self {            Object::Borrowed(object) => object.kind,            Object::Loose(object) => object.kind,        }    }     /// Returns the uncompressed size of the uncompressed object data in bytes    pub fn size(&self) -> usize {        match self {            Object::Borrowed(object) => object.data.len(),            Object::Loose(object) => object.size,        }    }} ///pub mod decode {    use crate::{compound::Object, loose};     /// Returned by [`Object::decode()`]    #[derive(thiserror::Error, Debug)]    #[allow(missing_docs)]    pub enum Error {        #[error(transparent)]        Decode(#[from] git_object::borrowed::Error),        #[error(transparent)]        LooseObject(#[from] loose::object::decode::Error),    }     impl<'a> Object<'a> {        /// Decode an object for accessing individual fields.        /// _Note_ that this is inefficient for big loose blobs, which should rather be streamed.        pub fn decode(&mut self) -> Result<git_object::borrowed::Object<'_>, Error> {            match self {                Object::Borrowed(object) => object.decode().map_err(Into::into),                Object::Loose(object) => object.decode().map_err(Into::into),            }        }    }} ///pub mod verify {    use crate::{compound::Object, loose};    use git_object::borrowed;     /// Returned by [`Object::verify_checksum()`]    #[derive(thiserror::Error, Debug)]    #[allow(missing_docs)]    pub enum Error {        #[error(transparent)]        Pack(#[from] crate::borrowed::verify::Error),        #[error(transparent)]        Loose(#[from] loose::object::verify::Error),    }     impl<'a> Object<'a> {        /// Assert whether the actual checksum of this object matches the `desired` one.        pub fn verify_checksum(&mut self, desired: borrowed::Id<'_>) -> Result<(), Error> {            match self {                Object::Borrowed(object) => object.verify_checksum(desired).map_err(Into::into),                Object::Loose(object) => object.verify_checksum(desired).map_err(Into::into),            }        }    }} #[cfg(test)]mod tests {    use super::*;     #[test]    fn size_in_memory() {        assert_eq!(            std::mem::size_of::<Object<'_>>(),            856,            "the object size should not grow unexpectedly"        );    }}