Enum CopyAction 

pub enum CopyAction {
    Created {
        destination: Option<GlobalId>,
        via: NoCounterpart,
        link: Option<CopyLink>,
    },
    Updated {
        destination: GlobalId,
        via: CopyVia,
        link: Option<CopyLink>,
    },
    Unchanged {
        destination: GlobalId,
        via: CopyVia,
        link: Option<CopyLink>,
    },
    Orphaned {
        destination: GlobalId,
    },
}

The four things a copy can do to one item, and the id each of them is about.

Variants

Created

The destination held no counterpart, so one was created.

Fields

destination: Option<GlobalId>

The id it was created under, or null for a dry run that would have created one — there is no id, because nothing was.

via: NoCounterpart

That no rule found a counterpart. The one word it can be, so a report written before there was a via reads as saying it.

link: Option<CopyLink>

What the copy did to the link the copied item records for this destination at onetaskgraph.copies; absent for a dry run, which writes nothing.

Updated

The destination held a counterpart and it now reads as the source does.

Fields

destination: GlobalId

The item that was updated.

via: CopyVia

Which rule found it.

link: Option<CopyLink>

What the copy did to the copied item’s link; absent for a dry run.

Unchanged

The destination held a counterpart that already read that way; nothing was written.

Fields

destination: GlobalId

The item that already said it.

via: CopyVia

Which rule found it.

link: Option<CopyLink>

What the copy did to the copied item’s link; absent for a dry run.

Orphaned

The destination holds a counterpart the source no longer does. A copy never deletes, so it was left exactly as it is — and no rule was asked where it goes, and no link was touched, because it was not copied.

Fields

destination: GlobalId

The item that was left alone.

Implementations

impl CopyAction

pub fn destination(&self) -> Option<&GlobalId>

The qualified id this action is about, when there is one.

pub fn found_by(&self) -> Option<CopyVia>

Which rule found the counterpart, or None when none did — the item was created — and for an orphan, which no rule was asked about.

pub fn link(&self) -> Option<CopyLink>

What became of the copied item’s link, or None for a dry run and for an orphan.

pub fn name(&self) -> String

The word this action serializes as, taken from its own Serialize.

Read back off the wire form rather than written out again in a match, for the reason render::wire gives: a second spelling of unchanged would be a second place for it to drift from the one a caller reads.

Trait Implementations

impl Clone for CopyAction

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 CopyAction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CopyAction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CopyAction

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CopyAction

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CopyAction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CopyAction