Struct Operation

pub struct Operation {
    pub view_id: ViewId,
    pub parents: Vec<OperationId>,
    pub metadata: OperationMetadata,
    pub commit_predecessors: Option<BTreeMap<CommitId, Vec<CommitId>>>,
}

Represents an operation (transaction) on the repo view, just like how a Commit object represents an operation on the tree.

Operations and views are not meant to be exchanged between repos or users; they represent local state and history.

The operation history will almost always be linear. It will only have forks when parallel operations occurred. The parent is determined when the transaction starts. When the transaction commits, a lock will be taken and it will be checked that the current head of the operation graph is unchanged. If the current head has changed, there has been concurrent operation.

Fields

view_id: ViewId

parents: Vec<OperationId>

metadata: OperationMetadata

commit_predecessors: Option<BTreeMap<CommitId, Vec<CommitId>>>

Mapping from new commit to its predecessors, or None if predecessors weren’t recorded when the operation was written.

• commit_id: [] if the commit was newly created.
• commit_id: [predecessor_id, ..] if the commit was rewritten.

This mapping preserves all transitive predecessors if a commit was rewritten multiple times within the same transaction. For example, if X was rewritten as Y, then rebased as Z, these modifications are recorded as {Y: [X], Z: [Y]}.

Existing commits (including commits imported from Git) aren’t tracked even if they became visible at this operation.

Implementations

impl Operation

pub fn make_root(root_view_id: ViewId) -> Operation

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ContentHash for Operation

fn hash(&self, state: &mut impl Update)

Update the hasher state with this object’s content

impl Debug for Operation

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

Formats the value using the given formatter.

impl PartialEq for Operation

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Operation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Operation

impl StructuralPartialEq for Operation