use std::ops::DerefMut; use crate::easy; /// Configure how caches are used to speed up various git repository operationspub trait CacheAccessExt: easy::Access + Sized {    /// Sets the amount of space used at most for caching most recently accessed fully decoded objects, to `Some(bytes)`,    /// or `None` to deactivate it entirely.    ///    /// Note that it is unset by default well but can be enabled once there is time for performance optimization.    /// Well-chosen cache sizes can improve performance particularly if objects are accessed multiple times in a row.    /// The cache is configured to grow gradually.    ///    /// Note that a cache on application level should be considered as well as the best object access is not doing one.    ///    /// Returns the previous cache size.    fn object_cache_size(&self, bytes: impl Into<Option<usize>>) -> easy::borrow::state::Result<Option<usize>> {        let bytes = bytes.into();        Ok(std::mem::replace(            self.state().try_borrow_mut_object_cache()?.deref_mut(),            bytes.map(easy::object::cache::MemoryCappedHashmap::new),        )        .map(|c| c.capacity()))    }     /// Set the cache for speeding up pack access to `cache`, and return the previous set cache.    ///    /// It can be unset by using `git_repository::odb::pack::cache::Never`.    #[cfg(all(feature = "unstable", feature = "max-performance"))]    fn pack_cache(        &self,        cache: impl git_pack::cache::DecodeEntry + Send + 'static,    ) -> easy::borrow::state::Result<Box<dyn git_pack::cache::DecodeEntry + Send + 'static>> {        Ok(std::mem::replace(            self.state().try_borrow_mut_pack_cache()?.deref_mut(),            Box::new(cache),        ))    }     /// Read well-known environment variables related to caches and apply them to this instance, but not to clones of it - each    /// needs their own configuration.    ///    /// Note that environment configuration never fails due to invalid environment values, but it should be used with caution as it    /// could be used to cause high memory consumption.    ///    /// Use the `GITOXIDE_DISABLE_PACK_CACHE` environment variable to turn off any pack cache, which can be beneficial when it's known that    /// the cache efficiency is low. Use `GITOXIDE_PACK_CACHE_MEMORY=512MB` to use up to 512MB of RAM for the pack delta base    /// cache. If none of these are set, the default cache is fast enough to nearly never cause a (marginal) slow-down while providing    /// some gains most of the time. Note that the value given is _per-thread_.    fn apply_environment(self) -> easy::borrow::state::Result<Self> {        #[cfg(not(feature = "max-performance"))]        let pack_cache = git_pack::cache::Never;        #[cfg(feature = "max-performance")]        let pack_cache: easy::PackCache = {            use std::convert::TryInto;            if std::env::var_os("GITOXIDE_DISABLE_PACK_CACHE").is_some() {                Box::new(git_pack::cache::Never)            } else if let Some(bytes) = std::env::var("GITOXIDE_PACK_CACHE_MEMORY")                .ok()                .and_then(|v| {                    byte_unit::Byte::from_str(&v)                        .map_err(|err| log::warn!("Failed to parse {:?} into byte unit for pack cache: {}", v, err))                        .ok()                })                .and_then(|unit| {                    unit.get_bytes()                        .try_into()                        .map_err(|err| {                            log::warn!(                            "Parsed bytes value is not representable as usize. Defaulting to standard pack cache: {}",                            err                        )                        })                        .ok()                })            {                Box::new(git_pack::cache::lru::MemoryCappedHashmap::new(bytes))            } else {                Box::new(git_pack::cache::lru::StaticLinkedList::<64>::default())            }        };        *self.state().try_borrow_mut_pack_cache()? = pack_cache;        Ok(self)    }} impl<A> CacheAccessExt for A where A: easy::Access + Sized {}