Trait IntoWire 

pub trait IntoWire {
    const NEEDS_PREPARATION: bool = true;

    // Required method
    fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>;

    // Provided methods
    fn preflight(&self, _resources: &mut WirePreflight) -> Result<(), WireError> { ... }
    async fn prepare_wire(&self) -> Result<(), WireError> { ... }
    fn write_result_payload(
        &self,
        writer: &mut WireWriter,
    ) -> Result<Option<i32>, WireError> { ... }
}

Encode a concrete value without constructing an owned schema value.

Implementations must visit every resource in preflight before moving any handles in write_wire. After a successful preflight, write_wire must not fail except when a resource was concurrently transferred through an alias.

Provided Associated Constants

const NEEDS_PREPARATION: bool = true

False only when prepare_wire is a no-op for every value of this type. Resource preflight still runs regardless of this flag. Custom and derived implementations prepare by default, including those with no stream schema.

Required Methods

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

Provided Methods

fn preflight(&self, _resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

Wrap native stream endpoints without reading from them. This is called only after the complete value has passed resource preflight.

fn write_result_payload( &self, writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl IntoWire for ()

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

fn write_result_payload( &self, _writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

impl IntoWire for DateTime<Utc>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for Duration

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for PathBuf

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for String

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for bool

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for char

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for f32

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for f64

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for i8

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for i16

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for i32

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for i64

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for str

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for u8

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for u16

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for u32

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for u64

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl IntoWire for usize

const NEEDS_PREPARATION: bool = false

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C, D, E, F, G, H> IntoWire for (A, B, C, D, E, F, G, H)

where A: IntoWire, B: IntoWire, C: IntoWire, D: IntoWire, E: IntoWire, F: IntoWire, G: IntoWire, H: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C, D, E, F, G> IntoWire for (A, B, C, D, E, F, G)

where A: IntoWire, B: IntoWire, C: IntoWire, D: IntoWire, E: IntoWire, F: IntoWire, G: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C, D, E, F> IntoWire for (A, B, C, D, E, F)

where A: IntoWire, B: IntoWire, C: IntoWire, D: IntoWire, E: IntoWire, F: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C, D, E> IntoWire for (A, B, C, D, E)

where A: IntoWire, B: IntoWire, C: IntoWire, D: IntoWire, E: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C, D> IntoWire for (A, B, C, D)

where A: IntoWire, B: IntoWire, C: IntoWire, D: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B, C> IntoWire for (A, B, C)

where A: IntoWire, B: IntoWire, C: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A, B> IntoWire for (A, B)

where A: IntoWire, B: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<A> IntoWire for (A,)

where A: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<K, V> IntoWire for BTreeMap<K, V>

where K: IntoWire, V: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<K, V> IntoWire for HashMap<K, V>

where K: IntoWire, V: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<T, E> IntoWire for Result<T, E>

where T: IntoWire, E: IntoWire,

const NEEDS_PREPARATION: bool

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<T> IntoWire for &T

where T: IntoWire + ?Sized,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

fn write_result_payload( &self, writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

impl<T> IntoWire for Arc<T>

where T: IntoWire + ?Sized,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_result_payload( &self, writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

impl<T> IntoWire for Bound<T>

where T: IntoWire,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<T> IntoWire for Box<T>

where T: IntoWire + ?Sized,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_result_payload( &self, writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

impl<T> IntoWire for HashSet<T>

where T: IntoWire,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<T> IntoWire for Option<T>

where T: IntoWire,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

impl<T> IntoWire for Rc<T>

where T: IntoWire + ?Sized,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_result_payload( &self, writer: &mut WireWriter, ) -> Result<Option<i32>, WireError>

impl<T> IntoWire for Vec<T>

where T: IntoWire,

const NEEDS_PREPARATION: bool = T::NEEDS_PREPARATION

fn preflight(&self, resources: &mut WirePreflight) -> Result<(), WireError>

async fn prepare_wire(&self) -> Result<(), WireError>

fn write_wire(&self, writer: &mut WireWriter) -> Result<i32, WireError>

Implementors

impl IntoWire for AccountId

impl IntoWire for AgentAllFilter

impl IntoWire for AgentAnyFilter

impl IntoWire for AgentConfigVarsFilter

impl IntoWire for AgentCreatedAtFilter

impl IntoWire for AgentEnvFilter

impl IntoWire for AgentId

impl IntoWire for AgentMetadata

impl IntoWire for AgentNameFilter

impl IntoWire for AgentPropertyFilter

impl IntoWire for AgentStatus

impl IntoWire for AgentStatusFilter

impl IntoWire for AgentVersionFilter

impl IntoWire for CardId

impl IntoWire for CardView

impl IntoWire for ComponentId

impl IntoWire for EnvironmentId

impl IntoWire for FilterComparator

impl IntoWire for ForkDetails

impl IntoWire for ForkResult

impl IntoWire for GuestPermissionCardHandle

impl IntoWire for GuestQuotaTokenHandle

impl IntoWire for GuestSecretHandle

impl IntoWire for KernelModule

impl IntoWire for PatternGrant

impl IntoWire for PermissionCard

impl IntoWire for PermissionError

impl IntoWire for PolymorphicPermissionCard

impl IntoWire for ProcessExitStatus

impl IntoWire for PromiseId

impl IntoWire for QuotaToken

impl IntoWire for SchemaFingerprintV1

Available on crate feature guest only.

const NEEDS_PREPARATION: bool = false

impl IntoWire for SchemaValueStream

impl IntoWire for StringFilterComparator

impl IntoWire for Timestamp

impl IntoWire for UpdateMode

impl IntoWire for Uuid

impl<U> IntoWire for Quantity<U>

where U: QuantityUnit,