Struct RefTransaction 

pub struct RefTransaction { /* private fields */ }

Batch of ref updates prepared for super::RefStore::prepare.

Implementations

impl RefTransaction

pub fn new() -> Self

Start an empty transaction.

pub fn update(self, update: RefUpdate) -> Result<Self, RefStoreError>

Append an update, rejecting duplicate ref names in the same batch.

Errors

Returns RefStoreError::DuplicateUpdate when update.name was already queued.

pub fn push_update(&mut self, update: RefUpdate) -> Result<(), RefStoreError>

Append an update in place.

Errors

Returns RefStoreError::DuplicateUpdate when update.name was already queued.

pub fn updates(&self) -> &[RefUpdate]

Borrow the queued updates.

pub fn into_updates(self) -> Vec<RefUpdate>

Consume the transaction and return the update list.

pub fn reflog_renames(&self) -> &[RefReflogRename]

Reflog rename operations bundled with this transaction.

pub fn case_only_renames(&self) -> &[RefCaseOnlyRename]

Case-only ref renames bundled with this transaction.

pub fn with_reflog_rename(self, rename: RefReflogRename) -> Self

Append a branch reflog rename to this transaction.

pub fn with_case_only_rename(self, rename: RefCaseOnlyRename) -> Self

Append a case-only branch ref rename (files backend).

pub fn initial(self) -> Self

Mark this as the first ref transaction of a new repository, such as the remote refs a clone imports (Git’s initial ref transaction).

The files backend then writes the batch as one packed-refs rewrite, without a loose file or lock per ref, when every update creates a direct ref (no reflog, expectation Expected::Any or Expected::Missing) that does not exist yet in the common directory. Any other batch, and every other backend, commits as usual, so the flag never changes which refs end up stored, only how they are laid out.

The packed write takes only packed-refs.lock: callers promise no other writer is creating the same refs, which holds for a repository nobody else knows about yet.

pub fn is_initial(&self) -> bool

Whether Self::initial marked this transaction.

pub fn allowing_failures(self) -> Self

Allow per-ref rejections during prepare while committing the rest in one batch.

Rejections are returned from super::PreparedRefTransaction::rejected_updates. Compare-and-swap, directory/file, and object-target failures on one ref do not roll back sibling updates in the same transaction. Duplicate names, invalid ref names, and other whole-transaction errors still fail prepare entirely.

pub fn allows_failures(&self) -> bool

Whether Self::allowing_failures was set.

pub fn into_parts( self, ) -> (Vec<RefUpdate>, Vec<RefReflogRename>, Vec<RefCaseOnlyRename>)

Split into ref updates, reflog renames, and case-only ref renames.

Trait Implementations

impl Clone for RefTransaction

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RefTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RefTransaction

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RefTransaction

impl PartialEq for RefTransaction

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RefTransaction