Type Definition libpijul::pristine::sanakirja::MutTxn

type MutTxn<T> = GenericTxn<MutTxn<Arc<Env<Exclusive>>, T>>;

Trait Implementations

impl MutTxnT for MutTxn<()>

pub fn put_remote(
    &mut self,
    remote: &mut RemoteRef<Self>,
    k: u64,
    v: (Hash, Merkle)
) -> Result<bool, Error>

pub fn del_remote(
    &mut self,
    remote: &mut RemoteRef<Self>,
    k: u64
) -> Result<bool, Error>

pub fn open_or_create_channel(
    &mut self,
    name: &str
) -> Result<ChannelRef<Self>, Error>

Open a channel, creating it if it is missing. The return type is a Rc<RefCell<…>> in order to avoid:

pub fn fork(
    &mut self,
    channel: &ChannelRef<Self>,
    new_name: &str
) -> Result<ChannelRef<Self>, Error>

pub fn rename_channel(
    &mut self,
    channel: &mut ChannelRef<Self>,
    new_name: &str
) -> Result<(), Error>

pub fn drop_channel(&mut self, name: &str) -> Result<bool, Error>

pub fn open_or_create_remote(
    &mut self,
    name: &str
) -> Result<RemoteRef<Self>, Error>

pub fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Error>

pub fn drop_named_remote(&mut self, name: &str) -> Result<bool, Error>

pub fn commit(self) -> Result<(), Error>

Commit this transaction.

impl MutTxnTExt for MutTxn<()>

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

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

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

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

pub fn apply_deps_rec<C: ChangeStore>(
    &mut self,
    changes: &C,
    channel: &mut ChannelRef<Self>,
    hash: Hash
) -> Result<(), 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), Error>

pub fn apply_local_change(
    &mut self,
    channel: &mut ChannelRef<Self>,
    change: &Change,
    hash: Hash,
    inode_updates: &HashMap<usize, InodeUpdate>
) -> Result<(u64, Merkle), 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<(), 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, Error>

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

pub fn unrecord<C: ChangeStore>(
    &mut self,
    changes: &C,
    channel: &mut ChannelRef<Self>,
    hash: &Hash
) -> Result<bool, 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>, Error>

pub fn add_file(&mut self, path: &str) -> Result<(), Error>

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<(), Error>

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<(), Error>

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<(), Error>

pub fn remove_file(&mut self, a: &str) -> Result<(), Error>

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

pub fn archive_with_state<'a, P: ChangeStore, A: Archive>(
    &mut self,
    changes: &P,
    channel: &mut ChannelRef<Self>,
    state: Merkle,
    extra: &[Hash],
    arch: &mut A
) -> Result<Vec<Conflict>, 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>, Error>

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

impl TxnTExt for MutTxn<()>

pub fn is_directory(&self, inode: Inode) -> bool

pub fn is_tracked(&self, path: &str) -> bool

pub fn iter_working_copy<'txn>(&'txn self) -> WorkingCopyIterator<'txn, Self>

pub fn has_change(&self, channel: &ChannelRef<Self>, hash: Hash) -> Option<u64>

pub fn log<'channel, 'txn>(
    &'txn self,
    channel: &'channel Channel<Self>,
    from: u64
) -> Log<'txn, Self>

pub fn reverse_log<'channel, 'txn>(
    &'txn self,
    channel: &'channel Channel<Self>,
    from: Option<u64>
) -> RevLog<'txn, Self>

pub fn get_changes(
    &self,
    channel: &ChannelRef<Self>,
    n: u64
) -> Option<(Hash, Merkle)>

pub fn get_revchanges(&self, channel: &ChannelRef<Self>, h: Hash) -> Option<u64>

pub fn touched_files<'txn>(&'txn self, h: Hash) -> Option<Touched<'txn, Self>>

pub fn find_oldest_path<C: ChangeStore>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    position: Position<Hash>
) -> Result<(String, bool), Error>

pub fn find_youngest_path<C: ChangeStore>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    position: Position<Hash>
) -> Result<(String, bool), Error>

pub fn follow_oldest_path<C: ChangeStore>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    path: &str
) -> Result<(Position<ChangeId>, bool), Error>

pub fn output_file<C: ChangeStore, V: VertexBuffer>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    v0: Position<ChangeId>,
    out: &mut V
) -> Result<(), Error>

pub fn archive<'a, C: ChangeStore, A: Archive>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    arch: &mut A
) -> Result<Vec<Conflict>, Error>

pub fn archive_prefix<'a, C: ChangeStore, I: Iterator<Item = &'a str>, A: Archive>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    prefix: &mut I,
    arch: &mut A
) -> Result<Vec<Conflict>, Error>