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

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

Trait Implementations

impl ChannelMutTxnT for MutTxn<()>

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

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

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.

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

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

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

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

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

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

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

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

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

impl GraphMutTxnT for MutTxn<()>

fn put_graph(
    &mut self,
    graph: &mut Self::Graph,
    k: &Vertex<ChangeId>,
    e: &SerializedEdge
) -> 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.

fn del_graph(
    &mut self,
    graph: &mut Self::Graph,
    k: &Vertex<ChangeId>,
    e: Option<&SerializedEdge>
) -> 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.

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

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

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

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

fn split_block(
    &mut self,
    graph: &mut Self::Graph,
    key: &Vertex<ChangeId>,
    pos: ChangePosition,
    buf: &mut Vec<SerializedEdge>
) -> 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<()>

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

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

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:

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

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

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

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

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

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

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

Commit this transaction.

impl MutTxnTExt for MutTxn<()>

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

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

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

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

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

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

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

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, 

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, 

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

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

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,
    if_modified_since: Option<SystemTime>
) -> Result<Vec<Conflict>, OutputError<C::Error, Self::GraphError, R::Error>>

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).

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).

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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl TxnTExt for MutTxn<()>

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

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

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

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

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

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

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

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

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>

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

fn changeid_reverse_log<'txn>(
    &'txn self,
    channel: &Self::Channel,
    from: Option<L64>
) -> Result<RevCursor<Self, &'txn Self, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>, Self::GraphError>

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

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

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

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

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

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

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

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

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

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