#[doc(hidden)]

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

        quote! { self.txn.get(&self.#name, key, value) }

        quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
            Ok(x)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }
        }

        quote! { self.txn.get(&self.#name, key, value) . #post_ }

        quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
            Ok(x . #post_)
        } else {
            Err(TxnErr(SanakirjaError::PristineCorrupt))
        }}

        #[doc(hidden)]
        fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Option<#value> {

        fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

        #[doc(hidden)]
        fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value> {

        fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {

            self.txn.get(db, key, value)

            if let Ok(x) = self.txn.get(db, key, value) {
                Ok(x)
            } else {
                Err(TxnErr(SanakirjaError::PristineCorrupt))
            }

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

        #[doc(hidden)]
        fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Option<#value>;

        fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

        #[doc(hidden)]
        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value>;

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { GraphError }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

            crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

            Result<crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>

            crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

            Result<crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>

            #[doc(hidden)]

            #[doc(hidden)]

            ) -> Option<(#key, #value)>;
            #[doc(hidden)]

            ) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;

            ) -> Option<(#key, #value)>;

            ) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;

        #[doc(hidden)]

        ) -> crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>;

        ) -> Result<crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>;

            #[doc(hidden)]

        #[doc(hidden)]

            #[doc(hidden)]

            ) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

            ) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

            #[doc(hidden)]

            ) -> super::Cursor<Self, RT, Self::#cursor_name, #key, #value> {

            ) -> Result<super::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

                let mut cursor = txn.txn.set_cursors(&db, pos).0;
                super::Cursor {
                    cursor,
                    txn,
                    marker: std::marker::PhantomData,

                if let Ok((cursor, _)) = txn.txn.set_cursors(&db, pos) {
                    Ok(super::Cursor {
                        cursor,
                        txn,
                        marker: std::marker::PhantomData,
                    })
                } else {
                    Err(TxnErr(SanakirjaError::PristineCorrupt))

            #[doc(hidden)]

            ) -> super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

            ) -> Result<super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

                    self.txn.set_cursors(&db, pos).0

                    if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
                        x
                    } else {
                        return Err(TxnErr(SanakirjaError::PristineCorrupt))
                    }
                } else if let Ok(x) = self.txn.set_cursors_last(&db) {
                    x

                    self.txn.set_cursors_last(&db)

                    return Err(TxnErr(SanakirjaError::PristineCorrupt))

                super::RevCursor {

                Ok(super::RevCursor {

                }

                })

            #[doc(hidden)]

            #[doc(hidden)]

            ) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

            ) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

                let mut cursor = self.txn.set_cursors(&db, pos).0;
                super::Cursor {

                let mut cursor = if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
                    x
                } else {
                    return Err(TxnErr(SanakirjaError::PristineCorrupt))
                };
                Ok(super::Cursor {

                }

                })

            #[doc(hidden)]

            ) -> Option<(#key, #value)> {
                (unsafe { ::sanakirja::next(&self.txn, cursor) })
                    #post

            ) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = unsafe { ::sanakirja::next(&self.txn, cursor) } {
                    x
                } else {
                    return Err(TxnErr(SanakirjaError::PristineCorrupt))
                };
                Ok(x #post)

            #[doc(hidden)]

            ) -> Option<(#key, #value)> {
                (unsafe { ::sanakirja::prev(&self.txn, cursor) })
                    #post

            ) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
                let x = if let Ok(x) = unsafe { ::sanakirja::prev(&self.txn, cursor) } {
                    x
                } else {
                    return Err(TxnErr(SanakirjaError::PristineCorrupt))
                };
                Ok(x #post)

    let txnt = next(&mut input_iter);
    let txnt: proc_macro2::TokenStream = if txnt.is_empty() {
        proc_macro2::TokenStream::from(quote! { TxnT })
    } else {
        proc_macro2::TokenStream::from_iter(txnt.into_iter())
    };
    let error = next(&mut input_iter);
    let error: proc_macro2::TokenStream = if error.is_empty() {
        proc_macro2::TokenStream::from(quote! { GraphError })
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

            impl<T: TxnT, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::RevCursor<T, RT, T::#cursor_name, #key, #value>

            impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::RevCursor<T, RT, T::#cursor_name, #key, #value>

                type Item = (#key, #value);
                fn next(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_prev(&mut self.cursor)

                type Item = Result<(#key, #value), TxnErr<T::#error>>;
                fn next(&mut self) -> Option<Self::Item> {
                    match self.txn.#name_prev(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

            impl<T: TxnT, RT: std::ops::Deref<Target = T>>

            impl<T: #txnt, RT: std::ops::Deref<Target = T>>

                pub fn prev(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_prev(&mut self.cursor)

                pub fn prev(&mut self) -> Option<Result<(#key, #value), TxnErr<T::#error>>> {
                    match self.txn.#name_prev(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

            impl<T: TxnT, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>

            impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>

                type Item = (#key, #value);
                fn next(&mut self) -> Option<(#key, #value)> {
                    self.txn.#name_next(&mut self.cursor)

                type Item = Result<(#key, #value), TxnErr<T::#error>>;
                fn next(&mut self) -> Option<Self::Item> {
                    match self.txn.#name_next(&mut self.cursor) {
                        Ok(Some(x)) => Some(Ok(x)),
                        Ok(None) => None,
                        Err(e) => Some(Err(e)),
                    }

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

        #[doc(hidden)]

        ) -> Result<bool, Self::Error>;
        #[doc(hidden)]

        ) -> Result<bool, TxnErr<Self::#error>>;

        ) -> Result<bool, Self::Error>;

        ) -> Result<bool, TxnErr<Self::#error>>;

    let error = next(&mut input_iter);
    let error = if error.is_empty() {
        quote! { Error }
    } else {
        proc_macro2::TokenStream::from_iter(error.into_iter())
    };

            #[doc(hidden)]

            ) -> Result<bool, Self::Error> {
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

            #[doc(hidden)]

            ) -> Result<bool, Self::Error> {
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

            ) -> Result<bool, TxnErr<Self::#error>> {
                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

            #[doc(hidden)]

            ) -> Result<bool, Self::Error> {

            ) -> Result<bool, TxnErr<Self::#error>> {

                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

                Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

            #[doc(hidden)]

            ) -> Result<bool, Self::Error> {

            ) -> Result<bool, TxnErr<Self::#error>> {

                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

                Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)

version = "0.2.0"

version = "0.3.0"

use anyhow::bail;

use crate::{config, current_dir, Error};

use crate::{config, current_dir};

                    return Err(Error::NoRepoRoot.into());

                    bail!("No Pijul repository found")

                return Err((crate::Error::CouldNotReadConfig { path: config_path }).into());

                bail!("Could not read configuration file at {:?}", config_path)

            Err(Error::AlreadyInARepo.into())

            bail!("Already in a repository")

use crate::Error;

            return Err(Error::NotAuthenticated.into());

            bail!("Not authenticated")

                        return Err((Error::RemoteExit {
                            status: exit_status,
                        })
                        .into());

                        bail!("Remote exited with status {:?}", exit_status)

                            return Err((Error::RemoteExit {
                                status: exit_status,
                            })
                            .into());

                            bail!("Remote exited with status {:?}", exit_status)

                let h = txn.get_external(ch).unwrap();

                let h = txn.get_external(ch)?.unwrap();

            for (_, (h, _)) in txn.log(&channel_, 0) {
                hashes.push(h);

            for h in txn.log(&channel_, 0)? {
                hashes.push((h?.1).0);

use crate::Error;

            Err((Error::RemoteNotFound {
                remote: name.to_string(),
            })
            .into())

            bail!("Remote not found: {:?}", name)

        Err((Error::RemoteNotFound {
            remote: name.to_string(),
        })
        .into())

        bail!("Remote not found: {:?}", name)

            .iter_remote(&remote.borrow().remote, n)
            .filter_map(|(k, _)| if k >= n { Some(k) } else { None })

            .iter_remote(&remote.borrow().remote, n)?
            .filter_map(|k| {
                let k = k.unwrap().0;
                if k >= n {
                    Some(k)
                } else {
                    None
                }
            })

        let (mut b, (_, state)) = if let Some(last) = txn.last_remote(remote) {

        let (mut b, (_, state)) = if let Some(last) = txn.last_remote(remote)? {

            let (mid, (_, state)) = txn.get_remote_state(remote, mid).unwrap();

            let (mid, (_, state)) = txn.get_remote_state(remote, mid)?.unwrap();

                    return Err((crate::Error::Http {
                        status: res.status(),
                    })
                    .into());

                    bail!("HTTP error {:?}", res.status())

                if let Some(channel) = txn.load_channel(&channel) {
                    Ok(local::get_state(txn, &channel, mid))

                if let Some(channel) = txn.load_channel(&channel)? {
                    local::get_state(txn, &channel, mid)

                    let mut channel = txn.load_channel(&l.channel).unwrap();

                    let mut channel = txn.load_channel(&l.channel)?.unwrap();

                    let channel = txn.load_channel(&l.channel).unwrap();

                    let channel = txn.load_channel(&l.channel)?.unwrap();

                    return Err((crate::Error::Http {
                        status: res.status(),
                    })
                    .into());

                    bail!("HTTP error {:?}", res.status())

            for (n, (h, s)) in txn.iter_rev_remote(&remote.borrow().remote, None) {

            for x in txn.iter_rev_remote(&remote.borrow().remote, None)? {
                let (n, (h, s)) = x?;

                return Err((Error::StateNotFound { state }).into());

                bail!("State not found: {:?}", state)

        for (n, (h, s)) in txn.iter_remote(&remote.borrow().remote, 0) {

        for x in txn.iter_remote(&remote.borrow().remote, 0)? {
            let (n, (h, s)) = x?;

            return Err((Error::StateNotFound { state }).into());

            bail!("State not found: {:?}", state)

            if repo.changes.has_contents(*c, txn.get_internal(*c)) {

            if repo.changes.has_contents(*c, txn.get_internal(*c)?) {

            let change = if let Some(i) = txn.get_internal(*c) {

            let change = if let Some(i) = txn.get_internal(*c)? {

            if txn.is_alive(&channel, v) {

            if txn.is_alive(&channel, v)? {

        for (_, (h, _)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {

        for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
            let (_, (h, _)) = x?;

use libpijul::pristine::{Base32, Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::{MutTxnTExt, TxnTExt};

use libpijul::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::*;

) -> Option<(u64, Merkle)> {

) -> Result<Option<(u64, Merkle)>, anyhow::Error> {

        txn.get_changes(&channel, mid).map(|(_, m)| (mid, m))

        Ok(txn.get_changes(&channel, mid)?.map(|(_, m)| (mid, m)))

        txn.reverse_log(&channel.borrow(), None)
            .next()
            .map(|(n, (_, m))| (n, m))

        Ok(txn.reverse_log(&channel.borrow(), None)?.next().map(|n| {
            let (n, (_, m)) = n.unwrap();
            (n, m)
        }))

        let channel = txn.load_channel(&self.channel).unwrap();
        Ok(get_state(&txn, &channel, mid))

        let channel = txn.load_channel(&self.channel)?.unwrap();
        Ok(get_state(&txn, &channel, mid)?)

        let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel) {

        let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel)? {

                    change: remote_txn.get_external(p.change).unwrap(),

                    change: remote_txn.get_external(p.change)?.unwrap(),

                paths_.extend(libpijul::fs::iter_graph_descendants(
                    &remote_txn,
                    &remote_channel.borrow(),
                    p,
                ));

                paths_.extend(
                    libpijul::fs::iter_graph_descendants(
                        &remote_txn,
                        &remote_channel.borrow().graph,
                        p,
                    )?
                    .map(|x| x.unwrap()),
                );

        for (n, (h, m)) in remote_txn.log(&remote_channel.borrow(), from) {

        for x in remote_txn.log(&remote_channel.borrow(), from)? {
            let (n, (h, m)) = x?;

                let h_int = remote_txn.get_internal(h).unwrap();

                let h_int = remote_txn.get_internal(h)?.unwrap();

                    || paths_
                        .iter()
                        .any(|x| remote_txn.get_touched_files(*x, Some(h_int)).is_some())

                    || paths_.iter().any(|x| {
                        remote_txn
                            .get_touched_files(*x, Some(h_int))
                            .unwrap()
                            .is_some()
                    })

use anyhow::bail;

            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());

            bail!("HTTP error {:?}", res.status())

            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());

            bail!("HTTP error {:?}", res.status())

use anyhow::bail;

use libpijul::pristine::Base32;
use thiserror::Error;

}
#[derive(Debug, Error)]
pub enum Error {
    #[error("No Pijul repository found")]
    NoRepoRoot,
    #[error("Cannot access working directory")]
    CannotAccessWorkingDirectory,
    #[error("Already in a repository")]
    AlreadyInARepo,
    #[error("No such channel: {}", channel)]
    NoSuchChannel { channel: String },
    #[error("Protocol error. Is this the correct URL?")]
    ProtocolError { line: Vec<u8> },
    #[error("Not authenticated")]
    NotAuthenticated,
    #[error("No change message")]
    NoChangeMessage,
    #[error("Incorrect remote: {}", name)]
    IncorrectRemote { name: String },
    #[error("Unknown host key")]
    UnknownHostKey,
    #[error("Cannot record a binary change interactively. Use -a")]
    RecordBinaryChange,
    #[error("Remote not found: {:?}", remote)]
    RemoteNotFound { remote: String },
    #[error("No global config directory")]
    NoGlobalConfigDir,
    #[error("Could not parse global config")]
    CouldNotParseGlobal,
    #[error("Remote error: {}", msg)]
    Remote { msg: String },
    #[error("Remote exited with status {}", status)]
    RemoteExit { status: u32 },
    #[error("Missing remote")]
    MissingRemote,
    #[error("State not found in remote: {:?}", state)]
    StateNotFound { state: libpijul::pristine::Merkle },
    #[error("Missing dependencies for change {:?}", h)]
    MissingDep { h: libpijul::pristine::Hash },
    #[error("No prefixes given. Use `.` to record the current directory.")]
    NoRecordPrefixes,
    #[error("HTTP error: {}", status.as_str())]
    Http { status: reqwest::StatusCode },
    #[error("Could not parse configuration file at {:?}", path)]
    CouldNotReadConfig { path: PathBuf },
    #[error("No current channel")]
    NoCurrentChannel,
    #[error("Cannot delete the current channel")]
    CannotDeleteCurrentChannel,
    #[error("Channel not found: {:?}", channel)]
    ChannelNotFound { channel: String },
    #[error("Cannot reset, because there are unrecorded changes")]
    UnrecordedChanges,
    #[error("Could not infer repository name")]
    CouldNotInferRepositoryName { repo: String },
    #[error("Cannot unrecord change {}, because change {} depends on it", change, dep.to_base32())]
    CannotUnrecord {
        change: String,
        dep: libpijul::pristine::Hash,
    },

pub fn current_dir() -> Result<PathBuf, Error> {
    std::env::current_dir().map_err(|_| Error::CannotAccessWorkingDirectory)

pub fn current_dir() -> Result<PathBuf, anyhow::Error> {
    if let Ok(cur) = std::env::current_dir() {
        Ok(cur)
    } else {
        bail!("Cannot access working directory")
    }

use crate::Error;

use anyhow::bail;

            toml::from_slice(&s).map_err(|_| Error::CouldNotReadConfig { path: dir }.into())

            if let Ok(t) = toml::from_slice(&s) {
                Ok(t)
            } else {
                bail!("Could not read configuration file at {:?}", dir)
            }

            Err(Error::NoGlobalConfigDir.into())

            bail!("Global configuration file missing")

use libpijul::{Base32, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use libpijul::*;

        if let Some(mut channel) = txn.load_channel(channel_name) {

        if let Some(mut channel) = txn.load_channel(channel_name)? {

                    .reverse_log(&channel.borrow(), None)
                    .map(|(_, (h, _))| h)

                    .reverse_log(&channel.borrow(), None)?
                    .map(|h| (h.unwrap().1).0)

                for (p, d) in txn.iter_revdep(change_id) {

                for p in txn.iter_revdep(change_id)? {
                    let (p, d) = p?;

                    if txn.get_changeset(&channel_.changes, d, None).is_some() {
                        let dep = txn.get_external(d).unwrap();

                    if txn.get_changeset(&channel_.changes, d, None)?.is_some() {
                        let dep = txn.get_external(d)?.unwrap();

use crate::Error;

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

            bail!("No such channel: {:?}", channel_name)

                if let Some(mut channel) = txn.load_channel(current_channel) {

                if let Some(mut channel) = txn.load_channel(current_channel)? {

                        return Err(Error::UnrecordedChanges.into());

                        bail!("Cannot change channel, as there are unrecorded changes.")

use anyhow::bail;

use crate::Error;

            } else if let Some((_, (h, _))) = txn.reverse_log(&channel.borrow(), None).next() {
                h

            } else if let Some(h) = txn.reverse_log(&channel.borrow(), None)?.next() {
                (h?.1).0

            .map(|rec| rec.globalize(txn))

            .map(|rec| rec.globalize(txn).unwrap())

            LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new());

            LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new())?;

            return Err(Error::RecordBinaryChange.into());

            bail!("Cannot record a binary change interactively. Please use -a.")

            return Err(Error::NoChangeMessage.into());

            bail!("No change message")

use libpijul::{MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use libpijul::*;

                for r in txn.iter_remotes("") {

                for r in txn.iter_remotes("")? {
                    let r = r?;

            paths.extend(libpijul::fs::iter_graph_descendants(
                &txn,
                &channel.borrow(),
                p,
            ));

            paths.extend(
                libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                    .map(|x| x.unwrap()),
            );

        for (_, (h, m)) in txn.reverse_log(&channel.borrow(), None) {

        for x in txn.reverse_log(&channel.borrow(), None)? {
            let (_, (h, m)) = x?;

                if txn.remote_has_state(remote_changes, m) {

                if txn.remote_has_state(remote_changes, m)? {

                let h_int = txn.get_internal(h).unwrap();
                if !txn.remote_has_change(&remote_changes, h) {

                let h_int = txn.get_internal(h)?.unwrap();
                if !txn.remote_has_change(&remote_changes, h)? {

                            if txn.get_touched_files(*p, Some(h_int)).is_some() {

                            if txn.get_touched_files(*p, Some(h_int))?.is_some() {

                if let Some(channel) = txn.load_channel(remote_channel) {

                if let Some(channel) = txn.load_channel(remote_channel)? {

                    let h_int = txn.get_internal(h).unwrap();
                    if txn.get_changeset(&channel.changes, h_int, None).is_none() {

                    let h_int = txn.get_internal(h)?.unwrap();
                    if txn.get_changeset(&channel.changes, h_int, None)?.is_none() {

                                if txn.get_touched_files(*p, Some(h_int)).is_some() {

                                if txn.get_touched_files(*p, Some(h_int))?.is_some() {

                for (_, (h, m)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {
                    if txn.channel_has_state(&channel, m) {

                for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
                    let (h, m) = x?.1;
                    if txn.channel_has_state(&channel, m)? {

                    } else if txn.get_revchanges(&channel, h).is_none() {

                    } else if txn.get_revchanges(&channel, h)?.is_none() {

                    inodes_.extend(libpijul::fs::iter_graph_descendants(
                        &txn,
                        &channel.borrow(),
                        p,
                    ));

                    inodes_.extend(
                        libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                            .map(|x| x.unwrap()),
                    );

                    change: txn.get_external(x.change).unwrap(),

                    change: txn.get_external(x.change).unwrap().unwrap(),

                if let Some(remote_channel) = txn.load_channel(remote_channel) {

                if let Some(remote_channel) = txn.load_channel(remote_channel)? {

                    for (_, (h, m)) in txn.reverse_log(&remote_channel, None) {
                        if txn.channel_has_state(&channel, m) {

                    for x in txn.reverse_log(&remote_channel, None)? {
                        let (h, m) = x?.1;
                        if txn.channel_has_state(&channel, m)? {

                        let h_int = txn.get_internal(h).unwrap();

                        let h_int = txn.get_internal(h)?.unwrap();

                            .get_changeset(&channel.borrow().changes, h_int, None)

                            .get_changeset(&channel.borrow().changes, h_int, None)?

                                    txn.get_rev_touched_files(h_int, Some(inode)).is_some()

                                    txn.get_rev_touched_files(h_int, Some(inode))
                                        .unwrap()
                                        .is_some()

                let i = if let Some(change) = txn.get_internal(i.change) {

                let i = if let Some(change) = txn.get_internal(i.change)? {

                if txn.remote_has_change(rem, d) {

                if txn.remote_has_change(rem, d)? {

use crate::repository::Repository;
use anyhow::bail;

use libpijul::{Base32, ChannelRef, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use libpijul::*;

use crate::repository::Repository;
use crate::Error;

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, Error> {
    if let Some(c) = txn.load_channel(name) {

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, anyhow::Error> {
    if let Some(c) = txn.load_channel(name)? {

        Err(Error::NoSuchChannel {
            channel: name.to_string(),
        })

        bail!("No such channel: {:?}", name)

                    for (n, (_, m)) in txn.log(&channel.borrow(), pos) {

                    for x in txn.log(&channel.borrow(), pos)? {
                        let (n, (_, m)) = x?;

                } else if let Some((n, (_, m))) = txn.reverse_log(&channel.borrow(), None).next() {

                } else if let Some(x) = txn.reverse_log(&channel.borrow(), None)?.next() {
                    let (n, (_, m)) = x?;

                            return Err((Error::ProtocolError {
                                line: buf.as_bytes().to_vec(),
                            })
                            .into());

                            bail!("Ambiguous path")

                        let h = txn.get_external(p.change).unwrap();

                        let h = txn.get_external(p.change)?.unwrap();

                        paths.extend(libpijul::fs::iter_graph_descendants(
                            &txn,
                            &channel.borrow(),
                            p,
                        ));

                        paths.extend(
                            libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
                                .map(|x| x.unwrap()),
                        );

                        return Err((Error::ProtocolError {
                            line: buf.as_bytes().to_vec(),
                        })
                        .into());

                        debug!("protocol line: {:?}", buf);
                        bail!("Protocol error")

                for (n, (h, m)) in txn.log(&channel.borrow(), from) {
                    let h_int = txn.get_internal(h).unwrap();

                for x in txn.log(&channel.borrow(), from)? {
                    let (n, (h, m)) = x?;
                    let h_int = txn.get_internal(h)?.unwrap();

                            x.change == h_int || txn.get_touched_files(*x, Some(h_int)).is_some()

                            x.change == h_int
                                || txn.get_touched_files(*x, Some(h_int)).unwrap().is_some()

                    return Err((Error::ProtocolError {
                        line: buf.as_bytes().to_vec(),
                    })
                    .into());

                    debug!("protocol error: {:?}", buf);
                    bail!("Protocol error")

                    return Err((Error::ProtocolError {
                        line: buf.as_bytes().to_vec(),
                    })
                    .into());

                    debug!("protocol error {:?}", buf);
                    bail!("Protocol error");

                for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel) {
                    o.write_all(&d)?;

                for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel)? {
                    o.write_all(&d?)?;

                    if txn.current_state(&channel.borrow()) == state && extra.is_empty() {

                    if txn.current_state(&channel.borrow())? == state && extra.is_empty() {

        .map(|rec| rec.globalize(txn))

        .map(|rec| rec.globalize(txn).unwrap())

    );

    )?;

        libpijul::change::dependencies(txn, channel, pending_change.changes.iter());

        libpijul::change::dependencies(txn, &channel.borrow(), pending_change.changes.iter())?;

use anyhow::bail;

use crate::Error;

        let channel = if let Some(channel) = txn.load_channel(channel_name) {

        let channel = if let Some(channel) = txn.load_channel(channel_name)? {

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

            bail!("No such channel: {:?}", channel_name)

            for (_, (h, _)) in txn.reverse_log(&channel.borrow(), None) {

            for h in txn.reverse_log(&channel.borrow(), None)? {
                let h = (h?.1).0;

            for (_, (h, mrk)) in txn.reverse_log(&channel.borrow(), None) {

            for h in txn.reverse_log(&channel.borrow(), None)? {
                let (h, mrk) = h?.1;

            if let Some(channel) = txn.load_channel(channel_name) {

            if let Some(channel) = txn.load_channel(channel_name)? {

        for (_, p) in txn.iter_working_copy() {

        for p in txn.iter_working_copy() {
            let p = p?.1;

                if !txn.is_tracked(&path_str) {

                if !txn.is_tracked(&path_str)? {

            if txn.is_tracked(&path_str) {

            if txn.is_tracked(&path_str)? {

            .map(|rec| rec.globalize(&txn))

            .map(|rec| rec.globalize(&txn).unwrap())

        );

        )?;

            full_dependencies(&txn, &channel)

            full_dependencies(&txn, &channel)?

            dependencies(&txn, &channel, change.changes.iter())

            dependencies(&txn, &channel.borrow(), change.changes.iter())?

use crate::Error;

use anyhow::bail;

        let channel = if let Some(channel) = txn.load_channel(&channel_name) {

        let channel = if let Some(channel) = txn.load_channel(&channel_name)? {

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

            bail!("No such channel: {:?}", channel_name)

                &channel.borrow(),

                &channel.borrow().graph,

            libpijul::pristine::debug(&txn, &channel, std::io::stdout())?;

            libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;

        libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel, 0)?;

        libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel.borrow(), 0)?;

use anyhow::bail;

use libpijul::{ChangeId, Channel, EdgeFlags, TxnT, TxnTExt, Vertex};

use libpijul::*;

use crate::Error;

        let channel = if let Some(channel) = txn.load_channel(&channel_name) {

        let channel = if let Some(channel) = txn.load_channel(&channel_name)? {

            return Err((Error::NoSuchChannel {
                channel: channel_name.to_string(),
            })
            .into());

            bail!("No such channel: {:?}", channel_name)

pub struct Creditor<'a, W: std::io::Write, T: TxnTExt> {

pub struct Creditor<'a, W: std::io::Write, T: ChannelTxnT> {

impl<'a, W: std::io::Write, T: TxnTExt> Creditor<'a, W, T> {

impl<'a, W: std::io::Write, T: ChannelTxnT> Creditor<'a, W, T> {

        use libpijul::Base32;

                .filter(|e| !e.introduced_by.is_root())

                .unwrap()

                let e = e.unwrap();
                if e.introduced_by.is_root() {
                    continue;
                }

use crate::repository::*;
use anyhow::bail;

use crate::repository::*;

            return Err((crate::Error::CouldNotInferRepositoryName { repo: self.remote }).into());

            bail!("Could not infer repository name from {:?}", self.remote)

use anyhow::bail;

                for channel in txn.iter_channels("") {

                for channel in txn.iter_channels("")? {
                    let channel = channel?;

                    return Err(crate::Error::CannotDeleteCurrentChannel.into());

                    bail!("Cannot delete current channel")

                    return Err(crate::Error::NoCurrentChannel.into());

                    bail!("No current channel")

                let mut channel = if let Some(channel) = txn.load_channel(from) {

                let mut channel = if let Some(channel) = txn.load_channel(from)? {

                    return Err((crate::Error::ChannelNotFound {
                        channel: from.to_string(),
                    })
                    .into());

                    bail!("No such channel: {:?}", from)

            let channel = if let Some(channel) = txn.load_channel(channel_name) {

            let channel = if let Some(channel) = txn.load_channel(channel_name)? {

            if let Some((_, (h, _))) = txn.reverse_log(&channel, None).next() {
                h

            if let Some(h) = txn.reverse_log(&channel, None)?.next() {
                (h?.1).0

                let mut channel = txn.load_channel(&channel_name).unwrap();

                let mut channel = txn.load_channel(&channel_name)?.unwrap();

                let channel = txn.load_channel(&channel_name).unwrap();

                let channel = txn.load_channel(&channel_name)?.unwrap();

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

        let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {

version = "1.0.0-alpha.26"

version = "1.0.0-alpha.27"

thiserror = "1.0"
libpijul = { version = "1.0.0-alpha.22", features = [ "tarball" ] }

libpijul = { version = "1.0.0-alpha.23", features = [ "tarball" ] }

sanakirja = "0.14.2"

sanakirja = "0.15.2"

    ) -> Result<(), Error<C::Error, T::Error>> {

    ) -> Result<(), Error<C::Error, T::GraphError>> {

    ) -> Result<(), AddError<T::Error>> {

    ) -> Result<(), AddError<T::GraphError>> {

        let t = std::thread::spawn(move || -> Result<(), AddError<T::Error>> {

        let t = std::thread::spawn(move || -> Result<(), AddError<T::GraphError>> {

    ) -> Result<(), Error<C::Error, T::Error>> {

    ) -> Result<(), Error<C::Error, T::GraphError>> {

pub fn undo_file_addition<T: MutTxnT>(

pub fn undo_file_addition<
    T: GraphMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(

) -> Result<(), T::Error> {

) -> Result<(), TxnErr<T::GraphError>> {

        if let Some(inode) = txn.get_revinodes(pos, None) {

        if let Some(inode) = txn.get_revinodes(pos, None)? {

pub fn undo_file_deletion<T: MutTxnT, P: ChangeStore>(

pub fn undo_file_deletion<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {

        let source = find_block_end(txn, &channel, internal_pos(txn, &e.from, change_id)?)?;

        let source = find_block_end(txn, &channel.graph, internal_pos(txn, &e.from, change_id)?)?;

fn restore<T: MutTxnT, P: ChangeStore>(

fn restore<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {

        let source_parent = iter_adjacent(

        let mut source_parent = None;
        for e in iter_adjacent(

            &channel,

            &channel.graph,

        )
        .find(|e| e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER))
        .unwrap()
        .dest;

        )? {
            let e = e?;
            if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
                source_parent = Some(e.dest);
                break;
            }
        }
        let source_parent = source_parent.unwrap();

        } else if let Some(inode) = txn.get_revinodes(source_parent, None) {

        } else if let Some(inode) = txn.get_revinodes(source_parent, None)? {

fn restore_inode<T: MutTxnT, P: ChangeStore>(

fn restore_inode<
    T: TreeMutTxnT + GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

) -> Result<Inode, super::UnrecordError<P::Error, T::Error>> {

) -> Result<Inode, super::UnrecordError<P::Error, T::TreeError>> {

        .get_file_name(|h| txn.get_external(h), source, &mut name)

        .get_file_name(|h| txn.get_external(h).unwrap(), source, &mut name)

    if let Some(inode) = txn.get_revinodes(dest, None) {

    if let Some(inode) = txn.get_revinodes(dest, None)? {

        let inode = crate::fs::create_new_inode(txn);
        put_tree_with_rev(txn, file_id.as_file_id(), inode).map_err(super::UnrecordError::Txn)?;
        put_inodes_with_rev(txn, inode, dest).map_err(super::UnrecordError::Txn)?;

        let inode = crate::fs::create_new_inode(txn)?;
        put_tree_with_rev(txn, file_id.as_file_id(), inode)?;
        put_inodes_with_rev(txn, inode, dest)?;

fn find_youngest_parent<T: TxnT>(

fn find_youngest_parent<T: ChannelTxnT>(

) -> Result<Vertex<ChangeId>, BlockError> {

) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {

        channel,

        &channel.graph,

    )
    .filter(|e| e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
    {

    )? {
        let e = e?;
        if !e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
            continue;
        }

                .get_changeset(&channel.changes, e.introduced_by, None)

                .get_changeset(&channel.changes, e.introduced_by, None)?

    find_block_end(txn, channel, next.unwrap().1)

    find_block_end(txn, &channel.graph, next.unwrap().1)

pub fn undo_file_reinsertion<P: ChangeStore, T: MutTxnT>(

pub fn undo_file_reinsertion<
    P: ChangeStore,
    T: GraphTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {

            if let Some(inode) = txn.get_revinodes(position, None) {
                del_inodes_with_rev(txn, inode, position).map_err(super::UnrecordError::Txn)?;

            if let Some(inode) = txn.get_revinodes(position, None)? {
                del_inodes_with_rev(txn, inode, position)?;

    Block(#[from] crate::pristine::BlockError),

    Block(#[from] crate::pristine::BlockError<TxnError>),

    InconsistentChange(#[from] crate::pristine::InconsistentChange),

    InconsistentChange(#[from] crate::pristine::InconsistentChange<TxnError>),

}
impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for UnrecordError<C, T>
{
    fn from(t: TxnErr<T>) -> Self {
        UnrecordError::Txn(t.0)
    }

) -> Result<bool, UnrecordError<P::Error, T::Error>> {

) -> Result<bool, UnrecordError<P::Error, T::GraphError>> {

    let change_id = if let Some(h) = txn.get_internal(*hash) {

    let change_id = if let Some(h) = txn.get_internal(*hash)? {

    let unused = unused_in_other_channels(txn, &channel, change_id);

    let unused = unused_in_other_channels(txn, &channel, change_id)?;

        assert!(txn.get_revdep(change_id, None).is_none());
        while txn.del_dep(change_id, None).map_err(UnrecordError::Txn)? {}
        txn.del_external(change_id, None)
            .map_err(UnrecordError::Txn)?;
        txn.del_internal(*hash, None).map_err(UnrecordError::Txn)?;

        assert!(txn.get_revdep(change_id, None)?.is_none());
        while txn.del_dep(change_id, None)? {}
        txn.del_external(change_id, None)?;
        txn.del_internal(*hash, None)?;

            let dep = txn.get_internal(*dep).unwrap();
            txn.del_revdep(dep, Some(change_id))
                .map_err(UnrecordError::Txn)?;

            let dep = txn.get_internal(*dep)?.unwrap();
            txn.del_revdep(dep, Some(change_id))?;

fn del_channel_changes<T: MutTxnT, P: ChangeStore>(

fn del_channel_changes<
    T: ChannelMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

) -> Result<(), UnrecordError<P::Error, T::Error>> {
    let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None) {

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
    let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None)? {

    for (p, d) in txn.iter_revdep(change_id) {

    for x in txn.iter_revdep(change_id)? {
        let (p, d) = x?;

        if txn.get_changeset(&channel.changes, d, None).is_some() {

        if txn.get_changeset(&channel.changes, d, None)?.is_some() {

    txn.del_changes(channel, change_id, timestamp)
        .map_err(UnrecordError::Txn)?;

    txn.del_changes(channel, change_id, timestamp)?;

) -> bool {

) -> Result<bool, TxnErr<T::GraphError>> {

    for br in txn.iter_channels("") {

    for br in txn.iter_channels("")? {
        let br = br?;

        if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None).is_some() {
            return false;

        if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None)?.is_some() {
            return Ok(false);

    true

    Ok(true)

fn unapply<T: MutTxnT, C: ChangeStore>(

fn unapply<
    T: ChannelMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    C: ChangeStore,
>(

) -> Result<(), UnrecordError<C::Error, T::Error>> {

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

            Atom::EdgeMap(ref newedges) => {
                unapply_edges(changes, txn, channel, change_id, newedges, &mut ws)?
            }

            Atom::EdgeMap(ref newedges) => unapply_edges(
                changes,
                txn,
                &mut channel.graph,
                change_id,
                newedges,
                &mut ws,
            )?,

                        channel,

                        &mut channel.graph,

                    )
                    .map_err(UnrecordError::Txn)?;

                    )?

                unapply_newvertex::<T, C>(txn, channel, change_id, &mut ws, newvertex)?

                unapply_newvertex::<T, C>(txn, &mut channel.graph, change_id, &mut ws, newvertex)?

    repair_newvertex_contexts::<T, C>(txn, channel, &mut ws, change_id)?;

    repair_newvertex_contexts::<T, C>(txn, &mut channel.graph, &mut ws, change_id)?;

            remove_zombies::<_, C>(txn, channel, &mut ws, change_id, n)?;

            remove_zombies::<_, C>(txn, &mut channel.graph, &mut ws, change_id, n)?;

                channel,

                &mut channel.graph,

                working_copy::undo_file_addition(txn, change_id, new_vertex)
                    .map_err(UnrecordError::Txn)?;

                working_copy::undo_file_addition(txn, change_id, new_vertex)?;

    crate::apply::clean_obsolete_pseudo_edges(txn, channel, &mut ws.apply, change_id)?;
    crate::apply::repair_cyclic_paths(txn, channel, &mut ws.apply)?;

    crate::apply::clean_obsolete_pseudo_edges(txn, &mut channel.graph, &mut ws.apply, change_id)?;
    crate::apply::repair_cyclic_paths(txn, &mut channel.graph, &mut ws.apply)?;

fn unapply_newvertex<T: MutTxnT, C: ChangeStore>(

fn unapply_newvertex<T: GraphMutTxnT, C: ChangeStore>(

    channel: &mut Channel<T>,

    channel: &mut T::Graph,

) -> Result<(), UnrecordError<C::Error, T::Error>> {

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

        for e in iter_adj_all(txn, channel, vertex) {

        for e in iter_adj_all(txn, channel, vertex)? {
            let e = e?;

    fn perform_del<C: ChangeStore, T: MutTxnT>(

    fn perform_del<C: ChangeStore, T: GraphMutTxnT>(

        channel: &mut Channel<T>,

        channel: &mut T::Graph,

    ) -> Result<(), UnrecordError<C::Error, T::Error>> {

    ) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

            )
            .map_err(UnrecordError::Txn)?;

            )?;

fn repair_newvertex_contexts<T: MutTxnT, C: ChangeStore>(

fn repair_newvertex_contexts<T: GraphMutTxnT, C: ChangeStore>(

    channel: &mut Channel<T>,

    channel: &mut T::Graph,

) -> Result<(), UnrecordError<C::Error, T::Error>> {

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

        if is_alive(txn, channel, up) {

        if is_alive(txn, channel, up)? {

        ) {

        )? {
            let parent = parent?;

            if !is_alive(txn, channel, parent) {

            if !is_alive(txn, channel, parent)? {

fn unapply_edges<T: MutTxnT, P: ChangeStore>(

fn unapply_edges<T: GraphMutTxnT, P: ChangeStore>(

    channel: &mut Channel<T>,

    channel: &mut T::Graph,

) -> Result<(), UnrecordError<P::Error, T::Error>> {

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {

    let ext = txn.get_external(change_id).unwrap();

    let ext = txn.get_external(change_id)?.unwrap();

        let intro = internal(txn, &edge.introduced_by, change_id).unwrap();

        let intro = internal(txn, &edge.introduced_by, change_id)?.unwrap();

fn must_reintroduce<T: TxnT, C: ChangeStore>(

fn must_reintroduce<T: GraphTxnT, C: ChangeStore>(

    channel: &Channel<T>,

    channel: &T::Graph,

) -> Result<bool, crate::apply::ApplyError<C::Error, T::Error>> {

) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {

        change: txn.get_external(b.change),

        change: txn.get_external(b.change)?,

    for e in iter_adj_all(txn, channel, a).filter(|e| {
        !e.flag.contains(EdgeFlags::PARENT)
            && e.dest == b.start_pos()
            && !e.introduced_by.is_root()
            && e.introduced_by != current_id
    }) {

    for e in iter_adj_all(txn, channel, a)? {
        let e = e?;
        if e.flag.contains(EdgeFlags::PARENT)
            || e.dest != b.start_pos()
            || e.introduced_by.is_root()
            || e.introduced_by == current_id
        {
            continue;
        }

        .map_err(crate::apply::ApplyError::Changestore)

fn edge_is_in_channel<T: TxnT, C: ChangeStore>(

fn edge_is_in_channel<T: GraphTxnT, C: ChangeStore>(

) -> Result<bool, C::Error> {

) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {

        for next in changes.change_deletes_position(|c| txn.get_external(c), s, pos)? {

        for next in changes
            .change_deletes_position(|c| txn.get_external(c).unwrap(), s, pos)
            .map_err(UnrecordError::Changestore)?
        {

            } else if let Some(i) = txn.get_internal(next) {

            } else if let Some(i) = txn.get_internal(next)? {

fn remove_zombies<T: MutTxnT, C: ChangeStore>(

fn remove_zombies<T: GraphMutTxnT, C: ChangeStore>(

    channel: &mut Channel<T>,

    channel: &mut T::Graph,

) -> Result<(), UnrecordError<C::Error, T::Error>> {

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {

                del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)
                    .map_err(UnrecordError::Txn)?;

                del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)?;

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)
                    .map_err(UnrecordError::Txn)?;

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)?;