[−][src]Trait libpijul::MutTxnTExt

pub trait MutTxnTExt: MutTxnT {
    pub fn apply_change_ws<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: Hash, 
        workspace: &mut ApplyWorkspace
    ) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>> { ... }
    pub fn apply_change_rec_ws<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: Hash, 
        workspace: &mut ApplyWorkspace
    ) -> Result<(), ApplyError<C::Error, Self::Error>> { ... }
    pub fn apply_change<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: Hash
    ) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>> { ... }
    pub fn apply_change_rec<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: Hash
    ) -> Result<(), ApplyError<C::Error, Self::Error>> { ... }
    pub fn apply_deps_rec<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: Hash
    ) -> Result<(), ApplyError<C::Error, Self::Error>> { ... }
    pub fn apply_local_change_ws(
        &mut self, 
        channel: &mut ChannelRef<Self>, 
        change: &Change, 
        hash: Hash, 
        inode_updates: &HashMap<usize, InodeUpdate>, 
        workspace: &mut ApplyWorkspace
    ) -> Result<(u64, Merkle), LocalApplyError<Self::Error>> { ... }
    pub fn apply_local_change(
        &mut self, 
        channel: &mut ChannelRef<Self>, 
        change: &Change, 
        hash: Hash, 
        inode_updates: &HashMap<usize, InodeUpdate>
    ) -> Result<(u64, Merkle), LocalApplyError<Self::Error>> { ... }
    pub fn record<W: WorkingCopy, C: ChangeStore>(
        &mut self, 
        builder: &mut RecordBuilder, 
        diff_algorithm: Algorithm, 
        channel: &mut ChannelRef<Self>, 
        working_copy: &mut W, 
        changes: &C, 
        prefix: &str
    ) -> Result<(), RecordError<C::Error, W::Error, Self::Error>> { ... }
    pub fn record_all<W: WorkingCopy, C: ChangeStore>(
        &mut self, 
        diff_algorithm: Algorithm, 
        channel: &mut ChannelRef<Self>, 
        working_copy: &mut W, 
        changes: &C, 
        prefix: &str
    ) -> Result<Recorded, RecordError<C::Error, W::Error, Self::Error>> { ... }
    pub fn apply_recorded<C: ChangeStore>(
        &mut self, 
        channel: &mut ChannelRef<Self>, 
        recorded: Recorded, 
        changestore: &C
    ) -> Result<Hash, ApplyError<C::Error, Self::Error>> { ... }
    pub fn unrecord<C: ChangeStore>(
        &mut self, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        hash: &Hash
    ) -> Result<bool, UnrecordError<C::Error, Self::Error>> { ... }
    pub fn output_repository_no_pending<R: WorkingCopy, C: ChangeStore>(
        &mut self, 
        repo: &mut R, 
        changes: &C, 
        channel: &mut ChannelRef<Self>, 
        prefix: &str, 
        output_name_conflicts: bool
    ) -> Result<Vec<Conflict>, OutputError<C::Error, Self::Error, R::Error>> { ... }
    pub fn add_file(&mut self, path: &str) -> Result<(), FsError<Self::Error>> { ... }
    pub fn add_dir(&mut self, path: &str) -> Result<(), FsError<Self::Error>> { ... }
    pub fn add(
        &mut self, 
        path: &str, 
        is_dir: bool
    ) -> Result<(), FsError<Self::Error>> { ... }
    pub fn move_file(
        &mut self, 
        a: &str, 
        b: &str
    ) -> Result<(), FsError<Self::Error>> { ... }
    pub fn remove_file(&mut self, a: &str) -> Result<(), FsError<Self::Error>> { ... }
    pub fn channel_from_dump<'a>(
        &'a mut self, 
        name: &str
    ) -> Result<ChannelFromDump<'a, Self>, ChannelDumpError<Self::Error>> { ... }
    pub fn archive_with_state<P: ChangeStore, A: Archive>(
        &mut self, 
        changes: &P, 
        channel: &mut ChannelRef<Self>, 
        state: Merkle, 
        extra: &[Hash], 
        arch: &mut A
    ) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>> { ... }
    pub fn archive_prefix_with_state<'a, P: ChangeStore, A: Archive, I: Iterator<Item = &'a str>>(
        &mut self, 
        changes: &P, 
        channel: &mut ChannelRef<Self>, 
        state: Merkle, 
        extra: &[Hash], 
        prefix: &mut I, 
        arch: &mut A
    ) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>> { ... }
}

Provided methods

`pub fn apply_change_ws<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash, workspace: &mut ApplyWorkspace ) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>>`[src]

`pub fn apply_change_rec_ws<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash, workspace: &mut ApplyWorkspace ) -> Result<(), ApplyError<C::Error, Self::Error>>`[src]

`pub fn apply_change<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash ) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>>`[src]

`pub fn apply_change_rec<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash ) -> Result<(), ApplyError<C::Error, Self::Error>>`[src]

`pub fn apply_deps_rec<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash ) -> Result<(), ApplyError<C::Error, Self::Error>>`[src]

`pub fn apply_local_change_ws( &mut self, channel: &mut ChannelRef<Self>, change: &Change, hash: Hash, inode_updates: &HashMap<usize, InodeUpdate>, workspace: &mut ApplyWorkspace ) -> Result<(u64, Merkle), LocalApplyError<Self::Error>>`[src]

`pub fn apply_local_change( &mut self, channel: &mut ChannelRef<Self>, change: &Change, hash: Hash, inode_updates: &HashMap<usize, InodeUpdate> ) -> Result<(u64, Merkle), LocalApplyError<Self::Error>>`[src]

`pub fn record<W: WorkingCopy, C: ChangeStore>( &mut self, builder: &mut RecordBuilder, diff_algorithm: Algorithm, channel: &mut ChannelRef<Self>, working_copy: &mut W, changes: &C, prefix: &str ) -> Result<(), RecordError<C::Error, W::Error, Self::Error>>`[src]

`pub fn record_all<W: WorkingCopy, C: ChangeStore>( &mut self, diff_algorithm: Algorithm, channel: &mut ChannelRef<Self>, working_copy: &mut W, changes: &C, prefix: &str ) -> Result<Recorded, RecordError<C::Error, W::Error, Self::Error>>`[src]

`pub fn apply_recorded<C: ChangeStore>( &mut self, channel: &mut ChannelRef<Self>, recorded: Recorded, changestore: &C ) -> Result<Hash, ApplyError<C::Error, Self::Error>>`[src]

`pub fn unrecord<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: &Hash ) -> Result<bool, UnrecordError<C::Error, Self::Error>>`[src]

`pub fn output_repository_no_pending<R: WorkingCopy, C: ChangeStore>( &mut self, repo: &mut R, changes: &C, channel: &mut ChannelRef<Self>, prefix: &str, output_name_conflicts: bool ) -> Result<Vec<Conflict>, OutputError<C::Error, Self::Error, R::Error>>`[src]

`pub fn add_file(&mut self, path: &str) -> Result<(), FsError<Self::Error>>`[src]

Register a file in the working copy, where the file is given by its path from the root of the repository, where the components of the path are separated by / (example path: a/b/c).

`pub fn add_dir(&mut self, path: &str) -> Result<(), FsError<Self::Error>>`[src]

Register a directory in the working copy, where the directory is given by its path from the root of the repository, where the components of the path are separated by / (example path: a/b/c).

`pub fn add( &mut self, path: &str, is_dir: bool ) -> Result<(), FsError<Self::Error>>`[src]

Register a file or directory in the working copy, given by its path from the root of the repository, where the components of the path are separated by / (example path: a/b/c).

`pub fn move_file( &mut self, a: &str, b: &str ) -> Result<(), FsError<Self::Error>>`[src]

`pub fn remove_file(&mut self, a: &str) -> Result<(), FsError<Self::Error>>`[src]

`pub fn channel_from_dump<'a>( &'a mut self, name: &str ) -> Result<ChannelFromDump<'a, Self>, ChannelDumpError<Self::Error>>`[src]

`pub fn archive_with_state<P: ChangeStore, A: Archive>( &mut self, changes: &P, channel: &mut ChannelRef<Self>, state: Merkle, extra: &[Hash], arch: &mut A ) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>>`[src]

`pub fn archive_prefix_with_state<'a, P: ChangeStore, A: Archive, I: Iterator<Item = &'a str>>( &mut self, changes: &P, channel: &mut ChannelRef<Self>, state: Merkle, extra: &[Hash], prefix: &mut I, arch: &mut A ) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>>`[src]

Warning: this method unrecords changes until finding the state. If this is not wanted, please fork the channel before calling.

Loading content...

Implementors

`impl MutTxnTExt for MutTxn<()>`[src]

Loading content...

[−][src]Trait libpijul::MutTxnTExt

Provided methods

pub fn apply_change_ws<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash, workspace: &mut ApplyWorkspace) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>>[src]

pub fn apply_change_rec_ws<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash, workspace: &mut ApplyWorkspace) -> Result<(), ApplyError<C::Error, Self::Error>>[src]

pub fn apply_change<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash) -> Result<(u64, Merkle), ApplyError<C::Error, Self::Error>>[src]

pub fn apply_change_rec<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash) -> Result<(), ApplyError<C::Error, Self::Error>>[src]

pub fn apply_deps_rec<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: Hash) -> Result<(), ApplyError<C::Error, Self::Error>>[src]

pub fn apply_local_change_ws( &mut self, channel: &mut ChannelRef<Self>, change: &Change, hash: Hash, inode_updates: &HashMap<usize, InodeUpdate>, workspace: &mut ApplyWorkspace) -> Result<(u64, Merkle), LocalApplyError<Self::Error>>[src]

pub fn apply_local_change( &mut self, channel: &mut ChannelRef<Self>, change: &Change, hash: Hash, inode_updates: &HashMap<usize, InodeUpdate>) -> Result<(u64, Merkle), LocalApplyError<Self::Error>>[src]

pub fn record<W: WorkingCopy, C: ChangeStore>( &mut self, builder: &mut RecordBuilder, diff_algorithm: Algorithm, channel: &mut ChannelRef<Self>, working_copy: &mut W, changes: &C, prefix: &str) -> Result<(), RecordError<C::Error, W::Error, Self::Error>>[src]

pub fn record_all<W: WorkingCopy, C: ChangeStore>( &mut self, diff_algorithm: Algorithm, channel: &mut ChannelRef<Self>, working_copy: &mut W, changes: &C, prefix: &str) -> Result<Recorded, RecordError<C::Error, W::Error, Self::Error>>[src]

pub fn apply_recorded<C: ChangeStore>( &mut self, channel: &mut ChannelRef<Self>, recorded: Recorded, changestore: &C) -> Result<Hash, ApplyError<C::Error, Self::Error>>[src]

pub fn unrecord<C: ChangeStore>( &mut self, changes: &C, channel: &mut ChannelRef<Self>, hash: &Hash) -> Result<bool, UnrecordError<C::Error, Self::Error>>[src]

pub fn output_repository_no_pending<R: WorkingCopy, C: ChangeStore>( &mut self, repo: &mut R, changes: &C, channel: &mut ChannelRef<Self>, prefix: &str, output_name_conflicts: bool) -> Result<Vec<Conflict>, OutputError<C::Error, Self::Error, R::Error>>[src]

pub fn add_file(&mut self, path: &str) -> Result<(), FsError<Self::Error>>[src]

pub fn add_dir(&mut self, path: &str) -> Result<(), FsError<Self::Error>>[src]

pub fn add( &mut self, path: &str, is_dir: bool) -> Result<(), FsError<Self::Error>>[src]

pub fn move_file( &mut self, a: &str, b: &str) -> Result<(), FsError<Self::Error>>[src]

pub fn remove_file(&mut self, a: &str) -> Result<(), FsError<Self::Error>>[src]

pub fn channel_from_dump<'a>( &'a mut self, name: &str) -> Result<ChannelFromDump<'a, Self>, ChannelDumpError<Self::Error>>[src]

pub fn archive_with_state<P: ChangeStore, A: Archive>( &mut self, changes: &P, channel: &mut ChannelRef<Self>, state: Merkle, extra: &[Hash], arch: &mut A) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>>[src]

pub fn archive_prefix_with_state<'a, P: ChangeStore, A: Archive, I: Iterator<Item = &'a str>>( &mut self, changes: &P, channel: &mut ChannelRef<Self>, state: Merkle, extra: &[Hash], prefix: &mut I, arch: &mut A) -> Result<Vec<Conflict>, ArchiveError<P::Error, Self::Error, A::Error>>[src]