Enum Reply 

pub enum Reply {
    Welcome {
        version: Version,
    },
    Description(Description),
    Availability(AvailabilityDecl),
    Applies {
        applies: bool,
    },
    Status {
        status: Option<String>,
    },
    LiveChoices {
        choices: Vec<ChoiceDecl>,
    },
    Signals(ReadingDecl),
    Done,
    Failed {
        kind: FailureKind,
        detail: String,
    },
    Ask(Ask),
}

What an addon says back.

Variants

Welcome

Answer to Request::Hello.

Fields

version: Version

What the addon’s SDK speaks.

Description(Description)

Answer to Request::Describe.

Availability(AvailabilityDecl)

Answer to Request::Availability.

Applies

Answer to Request::Applies.

Fields

applies: bool

Whether it is worth offering.

Status

Answer to Request::Status.

Fields

status: Option<String>

The sentence, if there is one.

LiveChoices

Answer to Request::LiveChoices.

Fields

choices: Vec<ChoiceDecl>

In the order the addon wants them shown — the ordering is a concept only the addon has, so the interface renders rather than sorts.

Signals(ReadingDecl)

Answer to Request::ReadSignals.

Done

It worked, and there is nothing to say. Answers Perform, Configure and Shutdown.

Failed

It did not work.

Fields

kind: FailureKind

Which kind, so the daemon can tell “no such action” from “the target is not running” without parsing prose.

detail: String

What to tell the user. Already a sentence.

Ask(Ask)

The addon wants one of its own credentials, mid-request.

Not really a reply: the daemon answers with Answer and the addon then carries on with the request it was already handling. It shares this channel because there is only one pipe.

Trait Implementations

impl Clone for Reply

fn clone(&self) -> Reply

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Reply

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Reply

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Reply

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

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 Reply

impl StructuralPartialEq for Reply