Struct wasi_cap_std_sync::dir::Dir

impl Dir

pub fn from_cap_std(dir: Dir) -> Self

Examples found in repository ?

src/lib.rs (line 122)

    pub fn preopened_dir(mut self, dir: Dir, guest_path: impl AsRef<Path>) -> Result<Self, Error> {
        let dir = Box::new(crate::dir::Dir::from_cap_std(dir));
        self.0.push_preopened_dir(dir, guest_path)?;
        Ok(self)
    }

More examples

Hide additional examples

src/dir.rs (line 89)

    pub fn open_dir_(&self, symlink_follow: bool, path: &str) -> Result<Self, Error> {
        let d = if symlink_follow {
            self.0.open_dir(Path::new(path))?
        } else {
            self.0.open_dir_nofollow(Path::new(path))?
        };
        Ok(Dir::from_cap_std(d))
    }

pub fn open_file_(
 &self,
 symlink_follow: bool,
 path: &str,
 oflags: OFlags,
 read: bool,
 write: bool,
 fdflags: FdFlags
) -> Result<File, Error>

Examples found in repository ?

src/dir.rs (line 124)

    async fn open_file(
        &self,
        symlink_follow: bool,
        path: &str,
        oflags: OFlags,
        read: bool,
        write: bool,
        fdflags: FdFlags,
    ) -> Result<Box<dyn WasiFile>, Error> {
        let f = self.open_file_(symlink_follow, path, oflags, read, write, fdflags)?;
        Ok(Box::new(f))
    }

pub fn open_dir_(&self, symlink_follow: bool, path: &str) -> Result<Self, Error>

Examples found in repository ?

src/dir.rs (line 129)

    async fn open_dir(&self, symlink_follow: bool, path: &str) -> Result<Box<dyn WasiDir>, Error> {
        let d = self.open_dir_(symlink_follow, path)?;
        Ok(Box::new(d))
    }

pub fn rename_(
 &self,
 src_path: &str,
 dest_dir: &Self,
 dest_path: &str
) -> Result<(), Error>

Examples found in repository ?

src/dir.rs (line 280)

    async fn rename(
        &self,
        src_path: &str,
        dest_dir: &dyn WasiDir,
        dest_path: &str,
    ) -> Result<(), Error> {
        let dest_dir = dest_dir
            .as_any()
            .downcast_ref::<Self>()
            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
        self.rename_(src_path, dest_dir, dest_path)
    }

pub fn hard_link_(
 &self,
 src_path: &str,
 target_dir: &Self,
 target_path: &str
) -> Result<(), Error>

Examples found in repository ?

src/dir.rs (line 292)

    async fn hard_link(
        &self,
        src_path: &str,
        target_dir: &dyn WasiDir,
        target_path: &str,
    ) -> Result<(), Error> {
        let target_dir = target_dir
            .as_any()
            .downcast_ref::<Self>()
            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
        self.hard_link_(src_path, target_dir, target_path)
    }

Trait Implementations§

impl WasiDir for Dir

fn as_any(&self) -> &dyn Any

fn open_file<'life0, 'life1, 'async_trait>(
 &'life0 self,
 symlink_follow: bool,
 path: &'life1 str,
 oflags: OFlags,
 read: bool,
 write: bool,
 fdflags: FdFlags
) -> Pin<Box<dyn Future<Output = Result<Box<dyn WasiFile>, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn open_dir<'life0, 'life1, 'async_trait>(
 &'life0 self,
 symlink_follow: bool,
 path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Box<dyn WasiDir>, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn create_dir<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn readdir<'life0, 'async_trait>(
 &'life0 self,
 cursor: ReaddirCursor
) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,

fn symlink<'life0, 'life1, 'life2, 'async_trait>(
 &'life0 self,
 src_path: &'life1 str,
 dest_path: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,
 'life2: 'async_trait,

fn remove_dir<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn unlink_file<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn read_link<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<PathBuf, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn get_filestat<'life0, 'async_trait>(
 &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,

fn get_path_filestat<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str,
 follow_symlinks: bool
) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

fn rename<'life0, 'life1, 'life2, 'life3, 'async_trait>(
 &'life0 self,
 src_path: &'life1 str,
 dest_dir: &'life2 dyn WasiDir,
 dest_path: &'life3 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,
 'life2: 'async_trait,
 'life3: 'async_trait,

fn hard_link<'life0, 'life1, 'life2, 'life3, 'async_trait>(
 &'life0 self,
 src_path: &'life1 str,
 target_dir: &'life2 dyn WasiDir,
 target_path: &'life3 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,
 'life2: 'async_trait,
 'life3: 'async_trait,

fn set_times<'life0, 'life1, 'async_trait>(
 &'life0 self,
 path: &'life1 str,
 atime: Option<SystemTimeSpec>,
 mtime: Option<SystemTimeSpec>,
 follow_symlinks: bool
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>where
 Self: 'async_trait,
 'life0: 'async_trait,
 'life1: 'async_trait,

Auto Trait Implementations§

impl UnwindSafe for Dir

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> GetSetFdFlags for T

fn get_fd_flags(&self) -> Result<FdFlags, Error>where
T: AsFilelike,

Query the “status” flags for the self file descriptor.

fn new_set_fd_flags(&self, fd_flags: FdFlags) -> Result<SetFdFlags<T>, Error>where
T: AsFilelike,

Create a new SetFdFlags value for use with set_fd_flags. Read more

fn set_fd_flags(&mut self, set_fd_flags: SetFdFlags<T>) -> Result<(), Error>where
T: AsFilelike,

Set the “status” flags for the self file descriptor. Read more

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointee for T

type Pointer = u32

fn debug(
pointer: <T as Pointee>::Pointer,
f: &mut Formatter<'_>
) -> Result<(), Error>

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more