Struct CommitRequest 

pub struct CommitRequest {
    pub commit_id: CommitId,
    pub message: Option<String>,
    pub operations: Vec<FilesystemOperation>,
}

One logical filesystem commit: an idempotency key, an optional caller annotation, and an ordered, non-empty list of operations.

The whole request is one commit. Operations resolve in order, each seeing the effects of the ones before it, and either all of them commit or none of them do. A convenience one-operation request is this same type with a single-element list, so it plans, fingerprints, and replays identically.

This is the wire CommitRequest minus the content tokens: proofs are checked at the surface that accepts them, and what reaches the planner is the commit itself.

Paths are parsed once at the surface that accepts the raw string (parse_mutation_path); a request always carries validated, normalized paths.

Fields

commit_id: CommitId

Client idempotency key for the whole request.

message: Option<String>

Caller annotation recorded on the commit. Part of the request’s identity: reusing a commit id with a different message conflicts.

operations: Vec<FilesystemOperation>

Ordered operations. Must be non-empty.

Implementations

impl CommitRequest

pub fn single( commit_id: CommitId, message: Option<String>, operation: FilesystemOperation, ) -> Self

A request carrying exactly one operation.

Trait Implementations

impl Clone for CommitRequest

fn clone(&self) -> CommitRequest

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: &CommitRequest) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CommitRequest