Trait wasi_common::snapshots::preview_0::wasi_unstable::WasiUnstable[−][src]

pub trait WasiUnstable {

Show methods    #[must_use]
    fn args_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        argv: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>, 
        argv_buf: &'life2 GuestPtr<'a, u8>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

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

    #[must_use]
    fn environ_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        environ: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>, 
        environ_buf: &'life2 GuestPtr<'a, u8>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

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

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

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

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

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

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

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

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

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

    #[must_use]
    fn fd_fdstat_set_rights<'life0, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        fs_rights_base: Rights, 
        fs_rights_inheriting: Rights
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

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

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

    #[must_use]
    fn fd_filestat_set_times<'life0, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        atim: Timestamp, 
        mtim: Timestamp, 
        fst_flags: Fstflags
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn fd_pread<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        iovs: &'life1 IovecArray<'a>, 
        offset: Filesize
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

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

    #[must_use]
    fn fd_prestat_dir_name<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        path: &'life1 GuestPtr<'a, u8>, 
        path_len: Size
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn fd_pwrite<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        iovs: &'life1 CiovecArray<'a>, 
        offset: Filesize
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn fd_read<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        iovs: &'life1 IovecArray<'a>
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn fd_readdir<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        buf: &'life1 GuestPtr<'a, u8>, 
        buf_len: Size, 
        cookie: Dircookie
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

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

    #[must_use]
    fn fd_seek<'life0, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        offset: Filedelta, 
        whence: Whence
    ) -> Pin<Box<dyn Future<Output = Result<Filesize, Error>> + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

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

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

    #[must_use]
    fn fd_write<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        iovs: &'life1 CiovecArray<'a>
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_create_directory<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        path: &'life1 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_filestat_get<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        flags: Lookupflags, 
        path: &'life1 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_filestat_set_times<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        flags: Lookupflags, 
        path: &'life1 GuestPtr<'a, str>, 
        atim: Timestamp, 
        mtim: Timestamp, 
        fst_flags: Fstflags
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_link<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        old_fd: Fd, 
        old_flags: Lookupflags, 
        old_path: &'life1 GuestPtr<'a, str>, 
        new_fd: Fd, 
        new_path: &'life2 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_open<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        dirflags: Lookupflags, 
        path: &'life1 GuestPtr<'a, str>, 
        oflags: Oflags, 
        fs_rights_base: Rights, 
        fs_rights_inheriting: Rights, 
        fdflags: Fdflags
    ) -> Pin<Box<dyn Future<Output = Result<Fd, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_readlink<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        path: &'life1 GuestPtr<'a, str>, 
        buf: &'life2 GuestPtr<'a, u8>, 
        buf_len: Size
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_remove_directory<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        path: &'life1 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_rename<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        old_path: &'life1 GuestPtr<'a, str>, 
        new_fd: Fd, 
        new_path: &'life2 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_symlink<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        old_path: &'life1 GuestPtr<'a, str>, 
        fd: Fd, 
        new_path: &'life2 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn path_unlink_file<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        path: &'life1 GuestPtr<'a, str>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn poll_oneoff<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self, 
        in_: &'life1 GuestPtr<'a, Subscription>, 
        out: &'life2 GuestPtr<'a, Event>, 
        nsubscriptions: Size
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn proc_exit<'life0, 'async_trait>(
        &'life0 self, 
        rval: Exitcode
    ) -> Pin<Box<dyn Future<Output = Trap> + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

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

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

    #[must_use]
    fn random_get<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        buf: &'life1 GuestPtr<'a, u8>, 
        buf_len: Size
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn sock_recv<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        ri_data: &'life1 IovecArray<'a>, 
        ri_flags: Riflags
    ) -> Pin<Box<dyn Future<Output = Result<(Size, Roflags), Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn sock_send<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self, 
        fd: Fd, 
        si_data: &'life1 CiovecArray<'a>, 
        si_flags: Siflags
    ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>>
    where
        'a: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

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

}

Required methods

#[must_use]
fn args_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    argv: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>,
    argv_buf: &'life2 GuestPtr<'a, u8>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

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

#[must_use]
fn environ_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    environ: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>,
    environ_buf: &'life2 GuestPtr<'a, u8>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

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

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

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

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

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

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

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

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

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

#[must_use]
fn fd_fdstat_set_rights<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    fs_rights_base: Rights,
    fs_rights_inheriting: Rights
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

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

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

#[must_use]
fn fd_filestat_set_times<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    atim: Timestamp,
    mtim: Timestamp,
    fst_flags: Fstflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn fd_pread<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 IovecArray<'a>,
    offset: Filesize
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

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

#[must_use]
fn fd_prestat_dir_name<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    path: &'life1 GuestPtr<'a, u8>,
    path_len: Size
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn fd_pwrite<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 CiovecArray<'a>,
    offset: Filesize
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn fd_read<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 IovecArray<'a>
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn fd_readdir<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    buf: &'life1 GuestPtr<'a, u8>,
    buf_len: Size,
    cookie: Dircookie
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

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

#[must_use]
fn fd_seek<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    offset: Filedelta,
    whence: Whence
) -> Pin<Box<dyn Future<Output = Result<Filesize, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

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

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

#[must_use]
fn fd_write<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 CiovecArray<'a>
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_create_directory<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_filestat_get<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    flags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_filestat_set_times<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    flags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>,
    atim: Timestamp,
    mtim: Timestamp,
    fst_flags: Fstflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_open<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    dirflags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>,
    oflags: Oflags,
    fs_rights_base: Rights,
    fs_rights_inheriting: Rights,
    fdflags: Fdflags
) -> Pin<Box<dyn Future<Output = Result<Fd, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_remove_directory<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn path_rename<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    fd: Fd,
    old_path: &'life1 GuestPtr<'a, str>,
    new_fd: Fd,
    new_path: &'life2 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn poll_oneoff<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    in_: &'life1 GuestPtr<'a, Subscription>,
    out: &'life2 GuestPtr<'a, Event>,
    nsubscriptions: Size
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn proc_exit<'life0, 'async_trait>(
    &'life0 self,
    rval: Exitcode
) -> Pin<Box<dyn Future<Output = Trap> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

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

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

#[must_use]
fn random_get<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 GuestPtr<'a, u8>,
    buf_len: Size
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn sock_recv<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    ri_data: &'life1 IovecArray<'a>,
    ri_flags: Riflags
) -> Pin<Box<dyn Future<Output = Result<(Size, Roflags), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]
fn sock_send<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    si_data: &'life1 CiovecArray<'a>,
    si_flags: Siflags
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

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

Implementors

impl WasiUnstable for WasiCtx[src]

fn args_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    argv: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>,
    argv_buf: &'life2 GuestPtr<'a, u8>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

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

fn environ_get<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    environ: &'life1 GuestPtr<'a, GuestPtr<'a, u8>>,
    environ_buf: &'life2 GuestPtr<'a, u8>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

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

fn clock_res_get<'life0, 'async_trait>(
    &'life0 self,
    id: Clockid
) -> Pin<Box<dyn Future<Output = Result<Timestamp, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn clock_time_get<'life0, 'async_trait>(
    &'life0 self,
    id: Clockid,
    precision: Timestamp
) -> Pin<Box<dyn Future<Output = Result<Timestamp, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_advise<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    offset: Filesize,
    len: Filesize,
    advice: Advice
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_allocate<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    offset: Filesize,
    len: Filesize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_close<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_datasync<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_fdstat_get<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<Fdstat, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_fdstat_set_flags<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    flags: Fdflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_fdstat_set_rights<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    fs_rights_base: Rights,
    fs_rights_inheriting: Rights
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

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

fn fd_filestat_set_size<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    size: Filesize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_filestat_set_times<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    atim: Timestamp,
    mtim: Timestamp,
    fst_flags: Fstflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_read<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 IovecArray<'a>
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn fd_pread<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    iovs: &'life1 IovecArray<'a>,
    offset: Filesize
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn fd_write<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    ciovs: &'life1 CiovecArray<'a>
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn fd_pwrite<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    ciovs: &'life1 CiovecArray<'a>,
    offset: Filesize
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn fd_prestat_get<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<Prestat, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_prestat_dir_name<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    path: &'life1 GuestPtr<'a, u8>,
    path_max_len: Size
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn fd_renumber<'life0, 'async_trait>(
    &'life0 self,
    from: Fd,
    to: Fd
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_seek<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd,
    offset: Filedelta,
    whence: Whence
) -> Pin<Box<dyn Future<Output = Result<Filesize, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_sync<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_tell<'life0, 'async_trait>(
    &'life0 self,
    fd: Fd
) -> Pin<Box<dyn Future<Output = Result<Filesize, Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn fd_readdir<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    fd: Fd,
    buf: &'life1 GuestPtr<'a, u8>,
    buf_len: Size,
    cookie: Dircookie
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_create_directory<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    dirfd: Fd,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_filestat_get<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    dirfd: Fd,
    flags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_filestat_set_times<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    dirfd: Fd,
    flags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>,
    atim: Timestamp,
    mtim: Timestamp,
    fst_flags: Fstflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_open<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    dirfd: Fd,
    dirflags: Lookupflags,
    path: &'life1 GuestPtr<'a, str>,
    oflags: Oflags,
    fs_rights_base: Rights,
    fs_rights_inheriting: Rights,
    fdflags: Fdflags
) -> Pin<Box<dyn Future<Output = Result<Fd, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_remove_directory<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    dirfd: Fd,
    path: &'life1 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn path_rename<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    src_fd: Fd,
    src_path: &'life1 GuestPtr<'a, str>,
    dest_fd: Fd,
    dest_path: &'life2 GuestPtr<'a, str>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fn poll_oneoff<'a, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    subs: &'life1 GuestPtr<'a, Subscription>,
    events: &'life2 GuestPtr<'a, Event>,
    nsubscriptions: Size
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fn proc_exit<'life0, 'async_trait>(
    &'life0 self,
    status: Exitcode
) -> Pin<Box<dyn Future<Output = Trap> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

fn proc_raise<'life0, 'async_trait>(
    &'life0 self,
    _sig: Signal
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]

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

fn random_get<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    buf: &'life1 GuestPtr<'a, u8>,
    buf_len: Size
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn sock_recv<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _fd: Fd,
    _ri_data: &'life1 IovecArray<'a>,
    _ri_flags: Riflags
) -> Pin<Box<dyn Future<Output = Result<(Size, Roflags), Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn sock_send<'a, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    _fd: Fd,
    _si_data: &'life1 CiovecArray<'a>,
    _si_flags: Siflags
) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fn sock_shutdown<'life0, 'async_trait>(
    &'life0 self,
    _fd: Fd,
    _how: Sdflags
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, [src]