Struct CommitRequest 

pub struct CommitRequest {

    pub id: String,
    pub repository: PathBuf,
    pub common_dir: PathBuf,
    pub git_dir: PathBuf,
    pub reference: String,
    pub base: String,
    pub changes: Vec<Change>,
    pub message: String,
    pub author: Option<String>,
    pub committer: String,
    pub amend: bool,
    pub tree: Option<String>,
    pub commit: Option<String>,
    pub cleanup: Option<Cleanup>,
    pub index: PathBuf,
    pub captured: u64,
}

What: A request to land one commit. Why: Every field the service needs to land it on the current branch without asking the client anything.

In TS you’d write (pseudocode):

type CommitRequest = { id; repository; commonDir; reference; base; changes; message; author?; committer };

Fields

id: String

Random identity of this invocation, kept across reconnects.

repository: PathBuf

Worktree root whose index is updated.

common_dir: PathBuf

Common git directory shared by the worktrees.

git_dir: PathBuf

The worktree’s own Git directory (.git of the main worktree, .git/worktrees/<id> of a linked one): the key of the service instance that lands the commit, which refuses a request that names another worktree’s.

reference: String

Full name of the branch the commit goes on.

base: String

The commit the client prepared against.

changes: Vec<Change>

The paths to change.

message: String

The commit message, exact bytes.

author: Option<String>

Name <email> seconds zone, or nothing to use the committer.

committer: String

Name <email> seconds zone.

amend: bool

Whether the commit replaces the branch tip: its parents are the base commit’s parents, and it lands only while the branch tip is still the base.

tree: Option<String>

The tree of an amend, which the client wrote into the repository’s object store; nothing for any other request, whose tree the service makes from the base and the changes.

commit: Option<String>

A commit Git built in a scratch repository (an editor, a signature), already in the repository’s object store. The service lands it as it is, only while the branch tip is still the base, and ignores the message, the identities and the tree of the request.

cleanup: Option<Cleanup>

The state files a conclusion removes once the commit has landed; only with a commit built elsewhere.

index: PathBuf

The real index of the worktree, whose lock the landing holds from before the branch moves until the new index is in place.

captured: u64

When the client finished capturing the worktree’s bytes: nanoseconds of CLOCK_MONOTONIC, which one clock gives every process of the host, so two captures of one worktree compare whichever process made them; zero when unknown. The service keeps it with the commit it lands, and a retry uses it to tell which of two overlapping captures is the later.

Implementations

impl CommitRequest

pub fn lands_alone(&self) -> bool

Whether the request lands alone and only while the branch tip equals its base: an amend, or a commit built elsewhere.

Trait Implementations

impl Clone for CommitRequest

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 CommitRequest

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

Formats the value using the given formatter.

impl Eq for CommitRequest

impl PartialEq for CommitRequest

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CommitRequest