Enum Handoff 

pub enum Handoff {
    Export {
        content: ExportContent,
        name: String,
    },
    Clipboard(String),
    Asset {
        hash: AssetHash,
        asset: Asset,
    },
}

What the editor hands back, once it has something to hand back.

A front end sends a command in and drains this list; it never asks the editor a question. One list for every kind of result, so a result of a new kind travels the way the others already do — and so a kernel that computes one off the frame (a PDF of a large document, on a thread) can add it when the work lands without the poll on the other side changing.

A list rather than a slot because one frame can owe several: a document that opens on five images hands all five out at once. They are delivered in the order they were left.

Variants

Export

Bytes to write out, under the name a host should suggest for them.

Fields

content: ExportContent

name: String

Clipboard(String)

Text for the system clipboard.

Asset

The bytes behind a hash the display list names, sent by the first frame that paints it and never again in this session. The Asset is the format as well as the bytes — the kernel measures and exports by it, the front end decodes by it — so both sides read one enum.

Fields

hash: AssetHash

asset: Asset

Trait Implementations

impl<'de> Deserialize<'de> for Handoff

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Handoff

fn eq(&self, other: &Handoff) -> 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 Handoff

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 Handoff