Trait wasmtime_wasi_http::wasi::io::streams::Host

pub trait Host {
    // Required methods
    fn read(
        &mut self,
        this: InputStream,
        len: u64
    ) -> Result<Result<(Vec<u8>, bool), StreamError>>;
    fn blocking_read(
        &mut self,
        this: InputStream,
        len: u64
    ) -> Result<Result<(Vec<u8>, bool), StreamError>>;
    fn skip(
        &mut self,
        this: InputStream,
        len: u64
    ) -> Result<Result<(u64, bool), StreamError>>;
    fn blocking_skip(
        &mut self,
        this: InputStream,
        len: u64
    ) -> Result<Result<(u64, bool), StreamError>>;
    fn subscribe_to_input_stream(
        &mut self,
        this: InputStream
    ) -> Result<Pollable>;
    fn drop_input_stream(&mut self, this: InputStream) -> Result<()>;
    fn write(
        &mut self,
        this: OutputStream,
        buf: Vec<u8>
    ) -> Result<Result<u64, StreamError>>;
    fn blocking_write(
        &mut self,
        this: OutputStream,
        buf: Vec<u8>
    ) -> Result<Result<u64, StreamError>>;
    fn write_zeroes(
        &mut self,
        this: OutputStream,
        len: u64
    ) -> Result<Result<u64, StreamError>>;
    fn blocking_write_zeroes(
        &mut self,
        this: OutputStream,
        len: u64
    ) -> Result<Result<u64, StreamError>>;
    fn splice(
        &mut self,
        this: OutputStream,
        src: InputStream,
        len: u64
    ) -> Result<Result<(u64, bool), StreamError>>;
    fn blocking_splice(
        &mut self,
        this: OutputStream,
        src: InputStream,
        len: u64
    ) -> Result<Result<(u64, bool), StreamError>>;
    fn forward(
        &mut self,
        this: OutputStream,
        src: InputStream
    ) -> Result<Result<u64, StreamError>>;
    fn subscribe_to_output_stream(
        &mut self,
        this: OutputStream
    ) -> Result<Pollable>;
    fn drop_output_stream(&mut self, this: OutputStream) -> Result<()>;
}

Required Methods

fn read( &mut self, this: InputStream, len: u64 ) -> Result<Result<(Vec<u8>, bool), StreamError>>

Read bytes from a stream.

This function returns a list of bytes containing the data that was read, along with a bool which, when true, indicates that the end of the stream was reached. The returned list will contain up to len bytes; it may return fewer than requested, but not more.

Once a stream has reached the end, subsequent calls to read or skip will always report end-of-stream rather than producing more data.

If len is 0, it represents a request to read 0 bytes, which should always succeed, assuming the stream hasn’t reached its end yet, and return an empty list.

The len here is a u64, but some callees may not be able to allocate a buffer as large as that would imply. FIXME: describe what happens if allocation fails.

fn blocking_read( &mut self, this: InputStream, len: u64 ) -> Result<Result<(Vec<u8>, bool), StreamError>>

Read bytes from a stream, with blocking.

This is similar to read, except that it blocks until at least one byte can be read.

fn skip( &mut self, this: InputStream, len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Skip bytes from a stream.

This is similar to the read function, but avoids copying the bytes into the instance.

Once a stream has reached the end, subsequent calls to read or skip will always report end-of-stream rather than producing more data.

This function returns the number of bytes skipped, along with a bool indicating whether the end of the stream was reached. The returned value will be at most len; it may be less.

fn blocking_skip( &mut self, this: InputStream, len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Skip bytes from a stream, with blocking.

This is similar to skip, except that it blocks until at least one byte can be consumed.

fn subscribe_to_input_stream(&mut self, this: InputStream) -> Result<Pollable>

Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed.

fn drop_input_stream(&mut self, this: InputStream) -> Result<()>

Dispose of the specified input-stream, after which it may no longer be used.

fn write( &mut self, this: OutputStream, buf: Vec<u8> ) -> Result<Result<u64, StreamError>>

Write bytes to a stream.

This function returns a u64 indicating the number of bytes from buf that were written; it may be less than the full list.

fn blocking_write( &mut self, this: OutputStream, buf: Vec<u8> ) -> Result<Result<u64, StreamError>>

Write bytes to a stream, with blocking.

This is similar to write, except that it blocks until at least one byte can be written.

fn write_zeroes( &mut self, this: OutputStream, len: u64 ) -> Result<Result<u64, StreamError>>

Write multiple zero bytes to a stream.

This function returns a u64 indicating the number of zero bytes that were written; it may be less than len.

fn blocking_write_zeroes( &mut self, this: OutputStream, len: u64 ) -> Result<Result<u64, StreamError>>

Write multiple zero bytes to a stream, with blocking.

This is similar to write-zeroes, except that it blocks until at least one byte can be written.

fn splice( &mut self, this: OutputStream, src: InputStream, len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Read from one stream and write to another.

This function returns the number of bytes transferred; it may be less than len.

Unlike other I/O functions, this function blocks until all the data read from the input stream has been written to the output stream.

fn blocking_splice( &mut self, this: OutputStream, src: InputStream, len: u64 ) -> Result<Result<(u64, bool), StreamError>>

Read from one stream and write to another, with blocking.

This is similar to splice, except that it blocks until at least one byte can be read.

fn forward( &mut self, this: OutputStream, src: InputStream ) -> Result<Result<u64, StreamError>>

Forward the entire contents of an input stream to an output stream.

This function repeatedly reads from the input stream and writes the data to the output stream, until the end of the input stream is reached, or an error is encountered.

Unlike other I/O functions, this function blocks until the end of the input stream is seen and all the data has been written to the output stream.

This function returns the number of bytes transferred.

fn subscribe_to_output_stream(&mut self, this: OutputStream) -> Result<Pollable>

Create a pollable which will resolve once either the specified stream is ready to accept bytes or the other end of the stream has been closed.

fn drop_output_stream(&mut self, this: OutputStream) -> Result<()>

Dispose of the specified output-stream, after which it may no longer be used.

Implementors

impl Host for WasiHttp