Trait Output 

pub trait Output {
    type IO: IoOutput;
    type Ctx: Context;
    type Error: From<Error>;

    // Required methods
    async fn write(&mut self, value: &str) -> Result<(), Self::Error>;
    fn split(&mut self) -> (&mut Self::IO, &Self::Ctx);
    fn context(&self) -> &Self::Ctx;

    // Provided method
    fn get_ctx<T>(&self) -> &T
       where Self::Ctx: ContextProvides<T> { ... }
}

Code generation output. This is a high-level trait intended to represent wherever you’re writing to, with associated context. It can be split into that context in order to separate the I/O stream itself.

Required Associated Types

type IO: IoOutput

The I/O stream type

type Ctx: Context

The context holder

type Error: From<Error>

The error type for write operations.

Required Methods

async fn write(&mut self, value: &str) -> Result<(), Self::Error>

Writes the given value to the output.

fn split(&mut self) -> (&mut Self::IO, &Self::Ctx)

Splits into the context and the I/O stream, so that they can be used separately

fn context(&self) -> &Self::Ctx

Gets all the context associated with this output

Provided Methods

fn get_ctx<T>(&self) -> &T

where Self::Ctx: ContextProvides<T>,

Gets a particular context value

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'o, O> Output for &'o mut O

where O: Output,

type IO = <O as Output>::IO

type Ctx = <O as Output>::Ctx

type Error = <O as Output>::Error

async fn write(&mut self, value: &str) -> Result<(), Self::Error>

fn split(&mut self) -> (&mut Self::IO, &Self::Ctx)

fn context(&self) -> &Self::Ctx

Implementors

impl<I> Output for SimpleOutput<I>

where I: IoOutput,

type IO = I

type Ctx = DynContext

type Error = Error