#![allow(missing_docs)]use std::ops::DerefMut; use git_odb::Find;use git_ref::file::ReferenceExt; use crate::{    easy,    easy::{Oid, Reference},}; pub mod namespace {    pub mod set {        use crate::easy;         #[derive(Debug, thiserror::Error)]        pub enum Error {            #[error(transparent)]            BorrowRepoMut(#[from] easy::borrow::repo::Error),            #[error(transparent)]            NameValidation(#[from] git_validate::refname::Error),        }    }} pub mod create {    use crate::easy;     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        Edit(#[from] easy::reference::edit::Error),        #[error(transparent)]        NameValidation(#[from] git_validate::reference::name::Error),    }} pub mod edit {    use crate::easy;     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        FileTransactionPrepare(#[from] git_ref::file::transaction::prepare::Error),        #[error(transparent)]        FileTransactionCommit(#[from] git_ref::file::transaction::commit::Error),        #[error(transparent)]        NameValidation(#[from] git_validate::reference::name::Error),        #[error("BUG: The repository could not be borrowed")]        BorrowRepo(#[from] easy::borrow::repo::Error),    }} pub mod peel {    use crate::easy;     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        PeelToId(#[from] git_ref::peel::to_id::Error),        #[error(transparent)]        PackedRefsOpen(#[from] git_ref::packed::buffer::open::Error),        #[error("BUG: Part of interior state could not be borrowed.")]        BorrowState(#[from] easy::borrow::state::Error),        #[error("BUG: The repository could not be borrowed")]        BorrowRepo(#[from] easy::borrow::repo::Error),    }     impl From<easy::reference::packed::Error> for Error {        fn from(err: easy::reference::packed::Error) -> Self {            match err {                easy::reference::packed::Error::PackedRefsOpen(err) => Error::PackedRefsOpen(err),                easy::reference::packed::Error::BorrowState(err) => Error::BorrowState(err),            }        }    }} impl<'repo, A> Reference<'repo, A> {    pub fn target(&self) -> git_ref::TargetRef<'_> {        self.inner.target.to_ref()    }     pub fn name(&self) -> git_ref::FullNameRef<'_> {        self.inner.name.to_ref()    }     pub fn detach(self) -> git_ref::Reference {        self.inner    }} impl<'repo, A> Reference<'repo, A>where    A: easy::Access + Sized,{    pub(crate) fn from_ref(reference: git_ref::Reference, access: &'repo A) -> Self {        Reference {            inner: reference,            access,        }    }     pub fn peel_to_id_in_place(&mut self) -> Result<Oid<'repo, A>, peel::Error> {        let repo = self.access.repo()?;        let state = self.access.state();        let mut pack_cache = state.try_borrow_mut_pack_cache()?;        let oid = self.inner.peel_to_id_in_place(            &repo.refs,            state.assure_packed_refs_uptodate(&repo.refs)?.packed_refs.as_ref(),            |oid, buf| {                repo.odb                    .try_find(oid, buf, pack_cache.deref_mut())                    .map(|po| po.map(|o| (o.kind, o.data)))            },        )?;        Ok(Oid::from_id(oid, self.access))    }     pub fn into_fully_peeled_id(mut self) -> Result<Oid<'repo, A>, peel::Error> {        self.peel_to_id_in_place()    }} pub mod log; pub(crate) mod packed {    use std::{        cell::{BorrowError, BorrowMutError},        time::SystemTime,    };     use git_ref::file;     use crate::easy;     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        PackedRefsOpen(#[from] git_ref::packed::buffer::open::Error),        #[error("BUG: Part of interior state could not be borrowed.")]        BorrowState(#[from] easy::borrow::state::Error),    }     impl From<std::cell::BorrowError> for Error {        fn from(err: BorrowError) -> Self {            Error::BorrowState(easy::borrow::state::Error::Borrow(err))        }    }    impl From<std::cell::BorrowMutError> for Error {        fn from(err: BorrowMutError) -> Self {            Error::BorrowState(easy::borrow::state::Error::BorrowMut(err))        }    }     #[derive(Default)]    pub(crate) struct ModifieablePackedRefsBuffer {        pub(crate) packed_refs: Option<git_ref::packed::Buffer>,        modified: Option<SystemTime>,    }     impl ModifieablePackedRefsBuffer {        pub fn assure_packed_refs_uptodate(            &mut self,            file: &file::Store,        ) -> Result<(), git_ref::packed::buffer::open::Error> {            let packed_refs_modified_time = || file.packed_refs_path().metadata().and_then(|m| m.modified()).ok();            if self.packed_refs.is_none() {                self.packed_refs = file.packed_buffer()?;                if self.packed_refs.is_some() {                    self.modified = packed_refs_modified_time();                }            } else {                let recent_modification = packed_refs_modified_time();                match (&self.modified, recent_modification) {                    (None, None) => {}                    (Some(_), None) => {                        self.packed_refs = None;                        self.modified = None                    }                    (Some(cached_time), Some(modified_time)) => {                        if *cached_time < modified_time {                            self.packed_refs = file.packed_buffer()?;                            self.modified = Some(modified_time);                        }                    }                    (None, Some(modified_time)) => {                        self.packed_refs = file.packed_buffer()?;                        self.modified = Some(modified_time);                    }                }            }            Ok(())        }    }} pub mod find {    use crate::easy;     pub mod existing {         use crate::easy::reference::find;         #[derive(Debug, thiserror::Error)]        pub enum Error {            #[error(transparent)]            Find(#[from] find::Error),            #[error("The reference did not exist even though that was expected")]            NotFound,        }    }     #[derive(Debug, thiserror::Error)]    pub enum Error {        #[error(transparent)]        Find(#[from] git_ref::file::find::Error),        #[error(transparent)]        PackedRefsOpen(#[from] git_ref::packed::buffer::open::Error),        #[error("BUG: Part of interior state could not be borrowed.")]        BorrowState(#[from] easy::borrow::state::Error),        #[error("BUG: The repository could not be borrowed")]        BorrowRepo(#[from] easy::borrow::repo::Error),    }     impl From<easy::reference::packed::Error> for Error {        fn from(err: easy::reference::packed::Error) -> Self {            match err {                easy::reference::packed::Error::PackedRefsOpen(err) => Error::PackedRefsOpen(err),                easy::reference::packed::Error::BorrowState(err) => Error::BorrowState(err),            }        }    }}