Struct libpijul::pristine::sanakirja::GenericTxn

pub struct GenericTxn<T: Transaction> { /* fields omitted */ }

A transaction, used both for mutable and immutable transactions, depending on type parameter T.

In Sanakirja, both sanakirja::Txn and sanakirja::MutTxn implement sanakirja::Transaction, explaining our implementation of TxnT for Txn<T> for all T: sanakirja::Transaction. This covers both mutable and immutable transactions in a single implementation.

Implementations

impl GenericTxn<Txn<Exclusive, Arc<Env<Exclusive>>>>

pub fn check_database(&self) -> DatabaseReport

impl GenericTxn<Txn<Exclusive, Arc<Env<Exclusive>>>>

pub fn load_const_channel(&self, name: &str) -> Option<Channel<Self>>

Trait Implementations

impl<T: Transaction> Send for GenericTxn<T>

This is actually safe because the only non-Send fields are open_channels and open_remotes, but we can't do anything with a ChannelRef whose transaction has been moved to another thread.

impl<T: Transaction> TxnT for GenericTxn<T>

type Graph = Db<Vertex<ChangeId>, Edge>

pub fn get_external(&self, p: ChangeId) -> Option<Hash>

Returns the external hash of an internal change identifier, if the change is known.

pub fn get_internal(&self, p: Hash) -> Option<ChangeId>

Returns the internal change identifier of change with external hash hash, if the change is known.

pub fn hash_from_prefix(&self, s: &str) -> Result<(Hash, ChangeId), Error>

pub fn hash_from_prefix_remote<'txn>(
    &'txn self,
    remote: &RemoteRef<Self>,
    s: &str
) -> Result<Hash, Error>

type Inodes = Db<Inode, Position<ChangeId>>

type Revinodes = Db<Position<ChangeId>, Inode>

type Tree = Db<UnsafePathId, Inode>

type Revtree = Db<Inode, UnsafePathId>

type Changeset = Db<ChangeId, u64>

type Revchangeset = Db<u64, (ChangeId, Merkle)>

type Channelstates = Db<Merkle, u64>

type Dep = Db<ChangeId, ChangeId>

type Revdep = Db<ChangeId, ChangeId>

pub fn iter_dep_ref<RT: Deref<Target = Self> + Clone>(
    txn: RT,
    p: ChangeId
) -> Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>

type Touched_files = Db<Position<ChangeId>, ChangeId>

type Rev_touched_files = Db<ChangeId, Position<ChangeId>>

type Partials = Db<UnsafeSmallStr, Position<ChangeId>>

pub fn load_channel(&self, name: &str) -> Option<ChannelRef<Self>>

pub fn load_remote(&self, name: &str) -> Option<RemoteRef<Self>>

type Channels = Db<UnsafeSmallStr, (u64, u64, u64, u64, u64, u64)>

pub fn iter_channels<'txn>(
    &'txn self,
    start: &str
) -> ChannelIterator<'txn, Self>

Iterate a function over all channels. The loop stops the first time f returns false.

type Remotes = Db<UnsafeSmallStr, (u64, u64, u64)>

pub fn iter_remotes<'txn>(
    &'txn self,
    start: &str
) -> RemotesIterator<'txn, Self>

pub fn iter_inodes<'txn>(
    &'txn self
) -> Cursor<Self, &'txn Self, Self::InodesCursor, Inode, Position<ChangeId>>

pub fn iter_revinodes<'txn>(
    &'txn self
) -> Cursor<Self, &'txn Self, Self::RevinodesCursor, Position<ChangeId>, Inode>

pub fn iter_revdep<'txn>(
    &'txn self,
    k: ChangeId
) -> Cursor<Self, &'txn Self, Self::DepCursor, ChangeId, ChangeId>

pub fn iter_dep<'txn>(
    &'txn self,
    k: ChangeId
) -> Cursor<Self, &'txn Self, Self::DepCursor, ChangeId, ChangeId>

pub fn iter_touched<'txn>(
    &'txn self,
    k: Position<ChangeId>
) -> Cursor<Self, &'txn Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>

pub fn iter_rev_touched<'txn>(
    &'txn self,
    k: ChangeId
) -> Cursor<Self, &'txn Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>

pub fn iter_partials<'txn>(
    &'txn self,
    k: &str
) -> Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>

type Remote = Db<u64, (Hash, Merkle)>

type Revremote = Db<Hash, u64>

type Remotestates = Db<Merkle, u64>

pub fn iter_remote<'txn>(
    &'txn self,
    remote: &Self::Remote,
    k: u64
) -> Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>

pub fn iter_rev_remote<'txn>(
    &'txn self,
    remote: &Self::Remote,
    k: Option<u64>
) -> RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>

pub fn get_remote(&mut self, name: &str) -> Option<RemoteRef<Self>>

pub fn last_remote(
    &self,
    remote: &Self::Remote
) -> Option<(u64, (Hash, Merkle))>

pub fn get_remote_state(
    &self,
    remote: &Self::Remote,
    n: u64
) -> Option<(u64, (Hash, Merkle))>

pub fn remote_has_change(&self, remote: &RemoteRef<Self>, hash: Hash) -> bool

pub fn remote_has_state(&self, remote: &RemoteRef<Self>, m: Merkle) -> bool

pub fn channel_has_state(&self, channel: &ChannelRef<Self>, m: Merkle) -> bool