Struct CopyReport 

pub struct CopyReport {
    pub items: Vec<CopyOutcome>,
    pub references_rewritten: u64,
    pub references_unresolved: u64,
    pub references_ambiguous: u64,
    pub delivers_rewritten: u64,
    pub delivered: Vec<Delivered>,
    pub spent: Option<Spent>,
}

What a copy did, one entry per item.

The same per-item outcomes reach every consumer: the machine-readable output renders this, the rendered output renders this, and a Rust caller is handed it.

Fields

items: Vec<CopyOutcome>

One entry per item the copy considered, in the order it considered them.

references_rewritten: u64

Reference occurrences the copy rewrote to the destination’s own location for the record they name.

A silent bound is indistinguishable from a bug, so the copy says what it did to the references the documents it carried hold. This and the two below are totals over the whole invocation rather than figures per document, and all three default to zero, so a consumer written against the output before they existed is unaffected.

What these figures do not claim. The referent set is a document’s own project, so a reference to a record in a different project is never recognised at all and cannot appear in Self::references_unresolved either. These are the references the copy recognised; they are not a census of every reference a document holds. Noticing an out-of-scope reference would need exactly the unbounded destination walk this design refuses.

references_unresolved: u64

Reference occurrences the copy recognised and left byte-for-byte as they were, because the correspondence could not be established.

references_ambiguous: u64

How many of Self::references_unresolved were left alone because the correspondence was ambiguous rather than merely absent. A sub-count, never larger than it.

Split out because the two mean different things to a reader. A reference with no counterpart is ordinary and expected under the bound above — the design working. An ambiguous one says the destination holds duplicate records for one work item, or the source reports one location for two records, and re-running the copy will never clear it.

delivers_rewritten: u64

delivers entries the copy rewrote to the destination’s own id for a member of the copied set, over the whole invocation. Every other entry arrives qualified and is not counted. Left out when zero, as the three figures above are.

delivered: Vec<Delivered>

One entry per delivered task the copy kept in step with a task it landed, after the whole copy was complete — see task status set, which reports the same entries. Left out when there were none.

A failed entry does not undo the copy: the tasks it landed stay landed, and the command exits 4.

spent: Option<Spent>

What this copy spent, summed over the sources in the command that meter their own requests — and absent, never zero, when none of them does.

Omitted from the wire when absent, like the three figures above, so a consumer written against the output before it existed reads the same document.

Trait Implementations

impl Clone for CopyReport

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 CopyReport

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CopyReport

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CopyReport

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 CopyReport

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CopyReport

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 CopyReport