use std::{convert::TryFrom, rc::Rc, sync::Arc}; use parking_lot::lock_api::{ArcRwLockReadGuard, ArcRwLockWriteGuard}; use crate::{easy, Easy, EasyArc, EasyArcExclusive, EasyShared, Repository}; impl From<Repository> for Easy {    fn from(repo: Repository) -> Self {        Easy {            repo: Rc::new(repo),            state: Default::default(),        }    }} impl TryFrom<Easy> for Repository {    type Error = easy::borrow::repo::Error;     fn try_from(value: Easy) -> Result<Self, Self::Error> {        Rc::try_unwrap(value.repo).map_err(|_| easy::borrow::repo::Error)    }} impl TryFrom<EasyArc> for Repository {    type Error = easy::borrow::repo::Error;     fn try_from(value: EasyArc) -> Result<Self, Self::Error> {        Arc::try_unwrap(value.repo).map_err(|_| easy::borrow::repo::Error)    }} impl From<Repository> for EasyArc {    fn from(repo: Repository) -> Self {        EasyArc {            repo: Arc::new(repo),            state: Default::default(),        }    }} impl From<Repository> for EasyArcExclusive {    fn from(repo: Repository) -> Self {        EasyArcExclusive {            repo: Arc::new(parking_lot::RwLock::new(repo)),            state: Default::default(),        }    }} /// # Which `Easy` is for me?////// For one-off commands and single-threaded applications, use [`EasyShared`] or [`Easy`] as they don't allow mutable repository/// access which won't be needed.////// When multiple threads are involved, use [`EasyArc`] instead.////// Finally, if there is the need for adapting to changed object packs on disk or working with namespaces, mutable `Repository` access/// is needed, as provided by `EasyArcExclusive`. Currently mutable shared access is only available in thread-save versions, but that/// shall be fixed in the future as Rust's support for GATs becomes stable.// TODO: Update this once there is `EasyExclusive` as well.impl Repository {    /// Transform this instance into an [`EasyShared`] with borrowed `Repository`.    ///    /// Since a standard reference is used, the repository can never be mutated, which is required for the    /// fewest operations.    pub fn to_easy(&self) -> EasyShared<'_> {        EasyShared {            repo: self,            state: Default::default(),        }    }    /// Transform this instance into an [`Easy`], offering shared immutable access to the repository, for the current thread.    pub fn into_easy(self) -> Easy {        self.into()    }     /// Transform this instance into an [`EasyArc`], offering shared immutable access to the repository for use across threads.    pub fn into_easy_arc(self) -> EasyArc {        self.into()    }     /// Transform this instance into an [`EasyArcExclusive`], offering shared immutable access to the repository for use across threads.    pub fn into_easy_arc_exclusive(self) -> EasyArcExclusive {        self.into()    }} impl<'repo> easy::Access for EasyShared<'repo> {    type RepoRef = &'repo Repository;    type RepoRefMut = &'repo mut Repository;     fn repo(&self) -> Result<Self::RepoRef, easy::borrow::repo::Error> {        Ok(self.repo)    }     fn repo_mut(&self) -> Result<Self::RepoRefMut, easy::borrow::repo::Error> {        Err(easy::borrow::repo::Error)    }     fn state(&self) -> &easy::State {        &self.state    }} impl easy::Access for Easy {    type RepoRef = Rc<Repository>; // TODO: this could be a reference with GATs    type RepoRefMut = &'static mut Repository; // this is a lie     fn repo(&self) -> Result<Self::RepoRef, easy::borrow::repo::Error> {        Ok(self.repo.clone())    }     /// TODO: With GATs, this can return an actual RefMut<'a, _> so mutability is possible in single-threaded mode.    fn repo_mut(&self) -> Result<Self::RepoRefMut, easy::borrow::repo::Error> {        Err(easy::borrow::repo::Error)    }     fn state(&self) -> &easy::State {        &self.state    }} impl easy::Access for EasyArc {    type RepoRef = Arc<Repository>;    type RepoRefMut = &'static mut Repository; // this is a lie     fn repo(&self) -> Result<Self::RepoRef, easy::borrow::repo::Error> {        Ok(self.repo.clone())    }    fn repo_mut(&self) -> Result<Self::RepoRefMut, easy::borrow::repo::Error> {        Err(easy::borrow::repo::Error)    }    fn state(&self) -> &easy::State {        &self.state    }} impl easy::Access for EasyArcExclusive {    type RepoRef = ArcRwLockReadGuard<parking_lot::RawRwLock, Repository>;    type RepoRefMut = ArcRwLockWriteGuard<parking_lot::RawRwLock, Repository>;     fn repo(&self) -> Result<Self::RepoRef, easy::borrow::repo::Error> {        Ok(self.repo.read_arc())    }    fn repo_mut(&self) -> Result<Self::RepoRefMut, easy::borrow::repo::Error> {        Ok(self.repo.write_arc())    }    fn state(&self) -> &easy::State {        &self.state    }}