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

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

Trait Implementations

impl ChannelMutTxnT for MutTxn<()>

pub fn graph_mut(c: &mut Self::Channel) -> &mut Self::Graph

pub fn touch_channel(&mut self, channel: &mut Self::Channel, t: Option<u64>)

pub fn put_changes(
    &mut self,
    channel: &mut Self::Channel,
    p: ChangeId,
    t: ApplyTimestamp,
    h: &Hash
) -> Result<Option<Merkle>, TxnErr<Self::GraphError>>

Add a change and a timestamp to a change table. Returns None if and only if (p, t) was already in the change table, in which case no insertion happened. Returns the new state else.

pub fn del_changes(
    &mut self,
    channel: &mut Self::Channel,
    p: ChangeId,
    t: ApplyTimestamp
) -> Result<bool, TxnErr<Self::GraphError>>

Delete a change from a change table. Returns true if and only if (p, t) was in the change table.

impl DepsMutTxnT for MutTxn<()>

pub fn put_dep(
    &mut self,
    k: ChangeId,
    v: ChangeId
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn del_dep(
    &mut self,
    k: ChangeId,
    v: Option<ChangeId>
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn put_revdep(
    &mut self,
    k: ChangeId,
    v: ChangeId
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn del_revdep(
    &mut self,
    k: ChangeId,
    v: Option<ChangeId>
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn put_touched_files(
    &mut self,
    k: Position<ChangeId>,
    v: ChangeId
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn del_touched_files(
    &mut self,
    k: Position<ChangeId>,
    v: Option<ChangeId>
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn put_rev_touched_files(
    &mut self,
    k: ChangeId,
    v: Position<ChangeId>
) -> Result<bool, TxnErr<Self::DepsError>>

pub fn del_rev_touched_files(
    &mut self,
    k: ChangeId,
    v: Option<Position<ChangeId>>
) -> Result<bool, TxnErr<Self::DepsError>>

impl GraphMutTxnT for MutTxn<()>

pub fn put_graph(
    &mut self,
    graph: &mut Self::Graph,
    k: Vertex<ChangeId>,
    e: Edge
) -> Result<bool, TxnErr<Self::GraphError>>

Insert a key and a value to a graph. Returns false if and only if (k, v) was already in the graph, in which case no insertion happened.

pub fn del_graph(
    &mut self,
    graph: &mut Self::Graph,
    k: Vertex<ChangeId>,
    e: Option<Edge>
) -> Result<bool, TxnErr<Self::GraphError>>

Delete a key and a value from a graph. Returns true if and only if (k, v) was in the graph.

pub fn put_internal(
    &mut self,
    k: Hash,
    v: ChangeId
) -> Result<bool, TxnErr<Self::GraphError>>

pub fn del_internal(
    &mut self,
    k: Hash,
    v: Option<ChangeId>
) -> Result<bool, TxnErr<Self::GraphError>>

pub fn put_external(
    &mut self,
    k: ChangeId,
    v: Hash
) -> Result<bool, TxnErr<Self::GraphError>>

pub fn del_external(
    &mut self,
    k: ChangeId,
    v: Option<Hash>
) -> Result<bool, TxnErr<Self::GraphError>>

pub fn split_block(
    &mut self,
    graph: &mut Self::Graph,
    key: Vertex<ChangeId>,
    pos: ChangePosition,
    buf: &mut Vec<Edge>
) -> Result<(), TxnErr<Self::GraphError>>

Split a key [a, b[ at position pos, yielding two keys [a, pos[ and [pos, b[ linked by an edge.

impl MutTxnT for MutTxn<()>

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

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

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

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>, ForkError<Self::GraphError>>

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

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

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

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

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

pub fn commit(mut self: Self) -> Result<(), Self::GraphError>

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), ApplyError<C::Error, Self::GraphError>>

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::GraphError>>

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

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

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

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::GraphError>>

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::GraphError>>

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::GraphError>> where
    <W as WorkingCopy>::Error: 'static, 

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::GraphError>> where
    <W as WorkingCopy>::Error: 'static, 

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

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

pub fn output_repository_no_pending<R: WorkingCopy, C: ChangeStore>(
    &mut self,
    repo: &mut R,
    changes: &C,
    channel: &mut ChannelRef<Self>,
    done: &mut HashMap<Position<ChangeId>, Vertex<ChangeId>>,
    prefix: &str,
    output_name_conflicts: bool,
    if_modified_since: Option<SystemTime>
) -> Result<Vec<Conflict>, OutputError<C::Error, Self::GraphError, R::Error>>

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

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::GraphError>>

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::GraphError>>

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::GraphError>>

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

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

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::GraphError, 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::GraphError, A::Error>>

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

impl TreeMutTxnT for MutTxn<()>

pub fn put_inodes(
    &mut self,
    k: Inode,
    v: Position<ChangeId>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn del_inodes(
    &mut self,
    k: Inode,
    v: Option<Position<ChangeId>>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn put_revinodes(
    &mut self,
    k: Position<ChangeId>,
    v: Inode
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn del_revinodes(
    &mut self,
    k: Position<ChangeId>,
    v: Option<Inode>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn put_tree(
    &mut self,
    k: PathId<'_>,
    v: Inode
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn del_tree(
    &mut self,
    k: PathId<'_>,
    v: Option<Inode>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn put_revtree(
    &mut self,
    k: Inode,
    v: PathId<'_>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn del_revtree(
    &mut self,
    k: Inode,
    v: Option<PathId<'_>>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn put_partials(
    &mut self,
    k: &str,
    e: Position<ChangeId>
) -> Result<bool, TxnErr<Self::TreeError>>

pub fn del_partials(
    &mut self,
    k: &str,
    e: Option<Position<ChangeId>>
) -> Result<bool, TxnErr<Self::TreeError>>

impl TxnTExt for MutTxn<()>

pub fn is_directory(&self, inode: Inode) -> Result<bool, Self::TreeError>

pub fn is_tracked(&self, path: &str) -> Result<bool, Self::TreeError>

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

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

pub fn is_alive(
    &self,
    channel: &Self::Channel,
    a: Vertex<ChangeId>
) -> Result<bool, Self::GraphError>

pub fn current_state(
    &self,
    channel: &Self::Channel
) -> Result<Merkle, Self::GraphError>

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

pub fn log_for_path<'channel, 'txn>(
    &'txn self,
    channel: &'channel Self::Channel,
    pos: Position<ChangeId>,
    from: u64
) -> Result<PathChangeset<'channel, 'txn, Self>, Self::GraphError>

pub fn rev_log_for_path<'channel, 'txn>(
    &'txn self,
    channel: &'channel Self::Channel,
    pos: Position<ChangeId>,
    from: u64
) -> Result<RevPathChangeset<'channel, 'txn, Self>, Self::DepsError>

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

pub fn changeid_reverse_log<'txn>(
    &'txn self,
    channel: &Self::Channel,
    from: Option<u64>
) -> Result<RevCursor<Self, &'txn Self, Self::RevchangesetCursor, u64, (ChangeId, Merkle)>, Self::GraphError>

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

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

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

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

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

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

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

pub fn archive<C: ChangeStore, A: Archive>(
    &self,
    changes: &C,
    channel: &ChannelRef<Self>,
    arch: &mut A
) -> Result<Vec<Conflict>, ArchiveError<C::Error, Self::GraphError, A::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>, ArchiveError<C::Error, Self::GraphError, A::Error>>

pub fn iter_adjacent<'txn>(
    &'txn self,
    graph: &'txn Self::Channel,
    key: Vertex<ChangeId>,
    min_flag: EdgeFlags,
    max_flag: EdgeFlags
) -> Result<AdjacentIterator<'txn, Self>, TxnErr<Self::GraphError>>