Enum Action 

pub enum Action {
    Edit {
        title: Title,
        target: MergeTarget,
    },
    Label {
        labels: BTreeSet<Label>,
    },
    Lifecycle {
        state: Lifecycle,
    },
    Assign {
        assignees: BTreeSet<Did>,
    },
    Merge {
        revision: RevisionId,
        commit: Oid,
    },
    Review {
        revision: RevisionId,
        summary: Option<String>,
        verdict: Option<Verdict>,
        labels: Vec<Label>,
    },
    ReviewRedact {
        review: ReviewId,
    },
    ReviewComment {
        review: ReviewId,
        body: String,
        location: Option<CodeLocation>,
        reply_to: Option<CommentId>,
        embeds: Vec<Embed<Uri>>,
    },
    ReviewCommentEdit {
        review: ReviewId,
        comment: EntryId,
        body: String,
        embeds: Vec<Embed<Uri>>,
    },
    ReviewCommentRedact {
        review: ReviewId,
        comment: EntryId,
    },
    ReviewCommentReact {
        review: ReviewId,
        comment: EntryId,
        reaction: Reaction,
        active: bool,
    },
    ReviewCommentResolve {
        review: ReviewId,
        comment: EntryId,
    },
    ReviewCommentUnresolve {
        review: ReviewId,
        comment: EntryId,
    },
    ReviewReact {
        review: ReviewId,
        reaction: Reaction,
        active: bool,
    },
    Revision {
        description: String,
        base: Oid,
        oid: Oid,
        resolves: BTreeSet<(EntryId, CommentId)>,
    },
    RevisionEdit {
        revision: RevisionId,
        description: String,
        embeds: Vec<Embed<Uri>>,
    },
    RevisionReact {
        revision: RevisionId,
        location: Option<CodeLocation>,
        reaction: Reaction,
        active: bool,
    },
    RevisionRedact {
        revision: RevisionId,
    },
    RevisionComment {
        revision: RevisionId,
        location: Option<CodeLocation>,
        body: String,
        reply_to: Option<CommentId>,
        embeds: Vec<Embed<Uri>>,
    },
    RevisionCommentEdit {
        revision: RevisionId,
        comment: CommentId,
        body: String,
        embeds: Vec<Embed<Uri>>,
    },
    RevisionCommentRedact {
        revision: RevisionId,
        comment: CommentId,
    },
    RevisionCommentReact {
        revision: RevisionId,
        comment: CommentId,
        reaction: Reaction,
        active: bool,
    },
    ReviewEdit(ReviewEdit),
}

Patch operation.

Variants

Edit

Fields

title: Title

target: MergeTarget

Label

Fields

labels: BTreeSet<Label>

Lifecycle

Fields

state: Lifecycle

Assign

Fields

assignees: BTreeSet<Did>

Merge

Fields

revision: RevisionId

commit: Oid

Review

Fields

revision: RevisionId

summary: Option<String>

verdict: Option<Verdict>

labels: Vec<Label>

ReviewRedact

Fields

review: ReviewId

ReviewComment

Fields

review: ReviewId

body: String

location: Option<CodeLocation>

reply_to: Option<CommentId>

Comment this is a reply to. Should be None if it’s the first comment. Should be Some otherwise.

embeds: Vec<Embed<Uri>>

Embeded content.

ReviewCommentEdit

Fields

review: ReviewId

comment: EntryId

body: String

embeds: Vec<Embed<Uri>>

ReviewCommentRedact

Fields

review: ReviewId

comment: EntryId

ReviewCommentReact

Fields

review: ReviewId

comment: EntryId

reaction: Reaction

active: bool

ReviewCommentResolve

Fields

review: ReviewId

comment: EntryId

ReviewCommentUnresolve

Fields

review: ReviewId

comment: EntryId

ReviewReact

React to the review.

Fields

review: ReviewId

reaction: Reaction

active: bool

Revision

Fields

description: String

base: Oid

oid: Oid

resolves: BTreeSet<(EntryId, CommentId)>

Review comments resolved by this revision.

RevisionEdit

Fields

revision: RevisionId

description: String

embeds: Vec<Embed<Uri>>

Embeded content.

RevisionReact

React to the revision.

Fields

revision: RevisionId

location: Option<CodeLocation>

reaction: Reaction

active: bool

RevisionRedact

Fields

revision: RevisionId

RevisionComment

Fields

revision: RevisionId

The revision to comment on.

location: Option<CodeLocation>

For comments on the revision code.

body: String

Comment body.

reply_to: Option<CommentId>

Comment this is a reply to. Should be None if it’s the top-level comment. Should be the root CommentId if it’s a top-level comment.

embeds: Vec<Embed<Uri>>

Embeded content.

RevisionCommentEdit

Edit a revision comment.

Fields

revision: RevisionId

comment: CommentId

body: String

embeds: Vec<Embed<Uri>>

RevisionCommentRedact

Redact a revision comment.

Fields

revision: RevisionId

comment: CommentId

RevisionCommentReact

React to a revision comment.

Fields

revision: RevisionId

comment: CommentId

reaction: Reaction

active: bool

ReviewEdit(ReviewEdit)

Edit a review’s summary, verdict, labels, and embeds.

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CobAction for Action

fn parents(&self) -> Vec<Oid>

Parent objects this action depends on. For example, patch revisions have the commit objects as their parent.

fn produces_identifier(&self) -> bool

The outcome of some actions are to be referred later. For example, one action may create a comment, followed by another action that may create a reply to the comment, referring to it. Since actions are stored as part of crate::cob::op::Op, and operations are the smallest identifiable units, this may lead to ambiguity. It would not be possible to to, say, address one particular comment out of two, if the corresponding actions of creations were part of the same operation. To help avoid this, implementations signal whether specific actions require “their own” identifier. This allows checking for multiple such actions before creating an operation.

impl Debug for Action

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Action

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Action

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

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

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 Action

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 Action

impl StructuralPartialEq for Action