Trait wasmtime_wasi::WasiFile[−][src]

pub trait WasiFile: Send {

Show methods    fn as_any(&self) -> &(dyn Any + 'static);

    #[must_use]
    fn datasync<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn sync<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn get_filetype<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn get_fdflags<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn set_fdflags<'life0, 'async_trait>(
        &'life0 mut self, 
        flags: FdFlags
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn get_filestat<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn set_filestat_size<'life0, 'async_trait>(
        &'life0 self, 
        _size: u64
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn advise<'life0, 'async_trait>(
        &'life0 self, 
        offset: u64, 
        len: u64, 
        advice: Advice
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn allocate<'life0, 'async_trait>(
        &'life0 self, 
        offset: u64, 
        len: u64
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn set_times<'life0, 'async_trait>(
        &'life0 self, 
        atime: Option<SystemTimeSpec>, 
        mtime: Option<SystemTimeSpec>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        bufs: &'life1 mut [IoSliceMut<'a>]
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        bufs: &'life1 mut [IoSliceMut<'a>], 
        offset: u64
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        bufs: &'life1 [IoSlice<'a>]
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        bufs: &'life1 [IoSlice<'a>], 
        offset: u64
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn seek<'life0, 'async_trait>(
        &'life0 self, 
        pos: SeekFrom
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn peek<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        buf: &'life1 mut [u8]
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn num_ready_bytes<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn readable<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn writable<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

}

Required methods

fn as_any(&self) -> &(dyn Any + 'static)[src]

#[must_use]
fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    flags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn advise<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn allocate<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn seek<'life0, 'async_trait>(
    &'life0 self,
    pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

Implementations on Foreign Types

impl<W> WasiFile for WritePipe<W> where
    W: Write + Any + Send + Sync, [src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    WritePipe<W>: 'async_trait, [src]

impl<R> WasiFile for ReadPipe<R> where
    R: Read + Any + Send + Sync, [src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    ReadPipe<R>: 'async_trait, [src]

Implementors

impl WasiFile for File[src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    offset: u64,
    len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    File: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    File: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    File: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>],
    offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    File: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    File: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    File: 'async_trait, [src]

impl WasiFile for Stderr[src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64,
    _advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 mut [IoSliceMut<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 [IoSlice<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    _pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stderr: 'async_trait, [src]

impl WasiFile for Stdin[src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64,
    _advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 mut [IoSliceMut<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 [IoSlice<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    _pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdin: 'async_trait, [src]

impl WasiFile for Stdout[src]

pub fn as_any(&self) -> &(dyn Any + 'static)[src]

pub fn datasync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn sync<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn get_filetype<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FileType, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn get_fdflags<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FdFlags, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn set_fdflags<'life0, 'async_trait>(
    &'life0 mut self,
    _fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn get_filestat<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn set_filestat_size<'life0, 'async_trait>(
    &'life0 self,
    _size: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn advise<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64,
    _advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn allocate<'life0, 'async_trait>(
    &'life0 self,
    _offset: u64,
    _len: u64
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn read_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 mut [IoSliceMut<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn read_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 mut [IoSliceMut<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn write_vectored<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    bufs: &'life1 [IoSlice<'a>]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn write_vectored_at<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _bufs: &'life1 [IoSlice<'a>],
    _offset: u64
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn seek<'life0, 'async_trait>(
    &'life0 self,
    _pos: SeekFrom
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn peek<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn set_times<'life0, 'async_trait>(
    &'life0 self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn num_ready_bytes<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn readable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]

pub fn writable<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait, Global>> where
    'life0: 'async_trait,
    Stdout: 'async_trait, [src]