Struct wasi_cap_std_sync::Dir[−][src]

pub struct Dir { /* fields omitted */ }
Expand description

A reference to an open directory on a filesystem.

This does not directly correspond to anything in std, however its methods correspond to the functions in std::fs and the constructor methods for std::fs::File.

Unlike std::fs, this API’s canonicalize returns a relative path since absolute paths don’t interoperate well with the capability model.

Implementations

impl Dir[src]

pub unsafe fn from_std_file(std_file: File) -> Dir[src]

Constructs a new instance of Self from the given std::fs::File.

To prevent race conditions on Windows, the file must be opened without FILE_SHARE_DELETE.

Safety

std::fs::File is not sandboxed and may access any path that the host process has access to.

pub fn into_std_file(self) -> File[src]

Consumes self and returns a std::fs::File.

pub fn open<P>(&self, path: P) -> Result<File, Error> where
    P: AsRef<Path>, [src]

Attempts to open a file in read-only mode.

This corresponds to std::fs::File::open, but only accesses paths relative to self.

pub fn open_with<P>(
    &self,
    path: P,
    options: &OpenOptions
) -> Result<File, Error> where
    P: AsRef<Path>, [src]

Opens a file at path with the options specified by self.

This corresponds to std::fs::OpenOptions::open.

Instead of being a method on OpenOptions, this is a method on Dir, and it only accesses paths relative to self.

pub fn open_dir<P>(&self, path: P) -> Result<Dir, Error> where
    P: AsRef<Path>, [src]

Attempts to open a directory.

pub fn create_dir<P>(&self, path: P) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Creates a new, empty directory at the provided path.

This corresponds to std::fs::create_dir, but only accesses paths relative to self.

pub fn create_dir_all<P>(&self, path: P) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Recursively create a directory and all of its parent components if they are missing.

This corresponds to std::fs::create_dir_all, but only accesses paths relative to self.

pub fn create_dir_with<P>(
    &self,
    path: P,
    dir_builder: &DirBuilder
) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Creates the specified directory with the options configured in this builder.

This corresponds to std::fs::DirBuilder::create.

pub fn create<P>(&self, path: P) -> Result<File, Error> where
    P: AsRef<Path>, [src]

Opens a file in write-only mode.

This corresponds to std::fs::File::create, but only accesses paths relative to self.

pub fn canonicalize<P>(&self, path: P) -> Result<PathBuf, Error> where
    P: AsRef<Path>, [src]

Returns the canonical form of a path with all intermediate components normalized and symbolic links resolved.

This corresponds to std::fs::canonicalize, but instead of returning an absolute path, returns a path relative to the directory represented by self.

pub fn copy<P, Q>(&self, from: P, to_dir: &Dir, to: Q) -> Result<u64, Error> where
    P: AsRef<Path>,
    Q: AsRef<Path>, [src]

Copies the contents of one file to another. This function will also copy the permission bits of the original file to the destination file.

This corresponds to std::fs::copy, but only accesses paths relative to self.

Creates a new hard link on a filesystem.

This corresponds to std::fs::hard_link, but only accesses paths relative to self.

pub fn metadata<P>(&self, path: P) -> Result<Metadata, Error> where
    P: AsRef<Path>, [src]

Given a path, query the file system to get information about a file, directory, etc.

This corresponds to std::fs::metadata, but only accesses paths relative to self.

pub fn dir_metadata(&self) -> Result<Metadata, Error>[src]

Queries metadata about the underlying directory.

This is similar to std::fs::File::metadata, but for Dir rather than for File.

pub fn entries(&self) -> Result<ReadDir, Error>[src]

Returns an iterator over the entries within self.

pub fn read_dir<P>(&self, path: P) -> Result<ReadDir, Error> where
    P: AsRef<Path>, [src]

Returns an iterator over the entries within a directory.

This corresponds to std::fs::read_dir, but only accesses paths relative to self.

pub fn read<P>(&self, path: P) -> Result<Vec<u8, Global>, Error> where
    P: AsRef<Path>, [src]

Read the entire contents of a file into a bytes vector.

This corresponds to std::fs::read, but only accesses paths relative to self.

Reads a symbolic link, returning the file that the link points to.

This corresponds to std::fs::read_link, but only accesses paths relative to self.

pub fn read_to_string<P>(&self, path: P) -> Result<String, Error> where
    P: AsRef<Path>, [src]

Read the entire contents of a file into a string.

This corresponds to std::fs::read_to_string, but only accesses paths relative to self.

pub fn remove_dir<P>(&self, path: P) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Removes an empty directory.

This corresponds to std::fs::remove_dir, but only accesses paths relative to self.

pub fn remove_dir_all<P>(&self, path: P) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Removes a directory at this path, after removing all its contents. Use carefully!

This corresponds to std::fs::remove_dir_all, but only accesses paths relative to self.

pub fn remove_open_dir(self) -> Result<(), Error>[src]

Remove the directory referenced by self and consume self.

Note that even though this implementation works in terms of handles as much as possible, removal is not guaranteed to be atomic with respect to a concurrent rename of the directory.

pub fn remove_open_dir_all(self) -> Result<(), Error>[src]

Removes the directory referenced by self, after removing all its contents, and consume self. Use carefully!

Note that even though this implementation works in terms of handles as much as possible, removal is not guaranteed to be atomic with respect to a concurrent rename of the directory.

pub fn remove_file<P>(&self, path: P) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Removes a file from a filesystem.

This corresponds to std::fs::remove_file, but only accesses paths relative to self.

pub fn rename<P, Q>(&self, from: P, to_dir: &Dir, to: Q) -> Result<(), Error> where
    P: AsRef<Path>,
    Q: AsRef<Path>, [src]

Rename a file or directory to a new name, replacing the original file if to already exists.

This corresponds to std::fs::rename, but only accesses paths relative to self.

pub fn set_permissions<P>(
    &self,
    path: P,
    perm: Permissions
) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Changes the permissions found on a file or a directory.

This corresponds to std::fs::set_permissions, but only accesses paths relative to self. Also, on some platforms, this function may fail if the file or directory cannot be opened for reading or writing first.

Query the metadata about a file without following symlinks.

This corresponds to std::fs::symlink_metadata, but only accesses paths relative to self.

pub fn write<P, C>(&self, path: P, contents: C) -> Result<(), Error> where
    C: AsRef<[u8]>,
    P: AsRef<Path>, [src]

Write a slice as the entire contents of a file.

This corresponds to std::fs::write, but only accesses paths relative to self.

Creates a new file symbolic link on a filesystem.

This corresponds to std::os::windows::fs::symlink_file, but only accesses paths relative to self.

Creates a new directory symlink on a filesystem.

This corresponds to std::os::windows::fs::symlink_dir, but only accesses paths relative to self.

pub fn try_clone(&self) -> Result<Dir, Error>[src]

Creates a new Dir instance that shares the same underlying file handle as the existing Dir instance.

pub fn exists<P>(&self, path: P) -> bool where
    P: AsRef<Path>, [src]

Returns true if the path points at an existing entity.

This corresponds to std::path::Path::exists, but only accesses paths relative to self.

pub fn is_file<P>(&self, path: P) -> bool where
    P: AsRef<Path>, [src]

Returns true if the path exists on disk and is pointing at a regular file.

This corresponds to std::path::Path::is_file, but only accesses paths relative to self.

pub fn is_dir<P>(&self, path: P) -> bool where
    P: AsRef<Path>, [src]

Checks if path is a directory.

This is similar to std::path::Path::is_dir in that it checks if path relative to Dir is a directory. This function will traverse symbolic links to query information about the destination file. In case of broken symbolic links, this will return false.

pub unsafe fn open_ambient_dir<P>(path: P) -> Result<Dir, Error> where
    P: AsRef<Path>, [src]

Constructs a new instance of Self by opening the given path as a directory using the host process’ ambient authority.

Safety

This function is not sandboxed and may access any path that the host process has access to.

Trait Implementations

impl AsRawHandle for Dir[src]

pub fn as_raw_handle(&self) -> *mut c_void[src]

Extracts the raw handle, without taking any ownership.

impl AsRawHandleOrSocket for Dir[src]

pub fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket[src]

Like AsRawHandle::as_raw_handle and AsRawSocket::as_raw_socket but can return either type. Read more

impl Debug for Dir[src]

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>[src]

Formats the value using the given formatter. Read more

impl DirExt for Dir[src]

pub fn set_atime<P>(&self, path: P, atime: SystemTimeSpec) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Set the last access time for a file on a filesystem. Read more

pub fn set_mtime<P>(&self, path: P, mtime: SystemTimeSpec) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Set the last modification time for a file on a filesystem. Read more

pub fn set_times<P>(
    &self,
    path: P,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Result<(), Error> where
    P: AsRef<Path>, [src]

Set the last access and modification times for a file on a filesystem. Read more

Set the last access and modification times for a file on a filesystem. This function does not follow symlink. Read more

Creates a new symbolic link on a filesystem. Read more

Creates a new file symbolic link on a filesystem. Read more

Creates a new directory symbolic link on a filesystem. Read more

pub fn open_dir_nofollow<P>(&self, path: P) -> Result<Dir, Error> where
    P: AsRef<Path>, [src]

Similar to cap_std::fs::Dir::open_dir, but fails if the path names a symlink. Read more

Removes a file or symlink from a filesystem. Read more

impl FromRawHandle for Dir[src]

pub unsafe fn from_raw_handle(handle: *mut c_void) -> Dir[src]

To prevent race conditions on Windows, the handle must be opened without FILE_SHARE_DELETE.

impl IntoRawHandle for Dir[src]

pub fn into_raw_handle(self) -> *mut c_void[src]

Consumes this object, returning the raw underlying handle. Read more

impl IntoRawHandleOrSocket for Dir[src]

pub fn into_raw_handle_or_socket(self) -> RawHandleOrSocket[src]

Like IntoRawHandle::into_raw_handle and IntoRawSocket::into_raw_socket but can return either type. Read more

impl OwnsRaw for Dir[src]

Auto Trait Implementations

impl RefUnwindSafe for Dir

impl Send for Dir

impl Sync for Dir

impl Unpin for Dir

impl UnwindSafe for Dir

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> AsUnsafeFile for T where
    T: AsRawHandle + AsUnsafeHandle + OwnsRaw, [src]

pub fn as_unsafe_file(&self) -> UnsafeFile[src]

Return the contained unsafe file.

fn as_file_view(&self) -> View<'_, File>[src]

Utility for returning a value which dereferences to a &File or &mut File. Read more

unsafe fn as_unscoped_file_view(&self) -> View<'static, File>[src]

Like as_file_view, but returns a value which is not explicitly tied to the lifetime of self. Read more

fn eq_file<Filelike>(&self, other: &Filelike) -> bool where
    Filelike: AsUnsafeFile, [src]

Test whether self.as_unsafe_file().as_unsafe_handle() is equal to other.as_unsafe_file().as_unsafe_handle(). Read more

impl<T> AsUnsafeHandle for T where
    T: AsRawHandleOrSocket + OwnsRaw, [src]

pub fn as_unsafe_handle(&self) -> UnsafeHandle[src]

Return the contained unsafe handle.

fn eq_handle<Handlelike>(&self, other: &Handlelike) -> bool where
    Handlelike: AsUnsafeHandle, [src]

Test whether self.as_unsafe_handle() is equal to other.as_unsafe_handle(). Read more

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> FileIoExt for T where
    T: AsUnsafeFile, [src]

pub fn advise(
    &self,
    _offset: u64,
    _len: u64,
    _advice: Advice
) -> Result<(), Error>[src]

Announce the expected access pattern of the data at the given offset.

pub fn allocate(&self, _offset: u64, _len: u64) -> Result<(), Error>[src]

Allocate space in the file, increasing the file size as needed, and ensuring that there are no holes under the given range. Read more

pub fn read(&self, buf: &mut [u8]) -> Result<usize, Error>[src]

Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more

pub fn read_exact(&self, buf: &mut [u8]) -> Result<(), Error>[src]

Read the exact number of bytes required to fill buf. Read more

pub fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize, Error>[src]

Reads a number of bytes starting from a given offset. Read more

pub fn read_exact_at(&self, buf: &mut [u8], offset: u64) -> Result<(), Error>[src]

Reads the exact number of byte required to fill buf from the given offset. Read more

pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>[src]

Like read, except that it reads into a slice of buffers. Read more

pub fn read_vectored_at(
    &self,
    bufs: &mut [IoSliceMut<'_>],
    offset: u64
) -> Result<usize, Error>[src]

Is to read_vectored what read_at is to read.

pub fn read_exact_vectored_at(
    &self,
    bufs: &mut [IoSliceMut<'_>],
    offset: u64
) -> Result<(), Error>[src]

Is to read_exact_vectored what read_exact_at is to read_exact.

pub fn is_read_vectored_at(&self) -> bool[src]

Determines if this Reader has an efficient read_vectored_at implementation.

pub fn read_to_end(&self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>[src]

Read all bytes until EOF in this source, placing them into buf. Read more

pub fn read_to_end_at(
    &self,
    buf: &mut Vec<u8, Global>,
    offset: u64
) -> Result<usize, Error>[src]

Read all bytes, starting at offset, until EOF in this source, placing them into buf. Read more

pub fn read_to_string(&self, buf: &mut String) -> Result<usize, Error>[src]

Read all bytes until EOF in this source, appending them to buf. Read more

pub fn read_to_string_at(
    &self,
    buf: &mut String,
    offset: u64
) -> Result<usize, Error>[src]

Read all bytes, starting at offset, until EOF in this source, appending them to buf. Read more

pub fn peek(&self, buf: &mut [u8]) -> Result<usize, Error>[src]

Read bytes from the current position without advancing the current position. Read more

pub fn write(&self, buf: &[u8]) -> Result<usize, Error>[src]

Write a buffer into this writer, returning how many bytes were written. Read more

pub fn write_all(&self, buf: &[u8]) -> Result<(), Error>[src]

Attempts to write an entire buffer into this writer. Read more

pub fn write_at(&self, buf: &[u8], offset: u64) -> Result<usize, Error>[src]

Writes a number of bytes starting from a given offset. Read more

pub fn write_all_at(&self, buf: &[u8], offset: u64) -> Result<(), Error>[src]

Attempts to write an entire buffer starting from a given offset. Read more

pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>[src]

Like write, except that it writes from a slice of buffers. Read more

pub fn write_vectored_at(
    &self,
    bufs: &[IoSlice<'_>],
    offset: u64
) -> Result<usize, Error>[src]

Is to write_vectored what write_at is to write.

pub fn write_all_vectored_at(
    &self,
    bufs: &mut [IoSlice<'_>],
    offset: u64
) -> Result<(), Error>[src]

Is to write_all_vectored what write_all_at is to write_all.

pub fn is_write_vectored_at(&self) -> bool[src]

Determines if this Writer has an efficient write_vectored_at implementation.

pub fn flush(&self) -> Result<(), Error>[src]

Flush this output stream, ensuring that all intermediately buffered contents reach their destination. Read more

pub fn write_fmt(&self, fmt: Arguments<'_>) -> Result<(), Error>[src]

Writes a formatted string into this writer, returning any error encountered. Read more

pub fn seek(&self, pos: SeekFrom) -> Result<u64, Error>[src]

Seek to an offset, in bytes, in a stream. Read more

pub fn stream_position(&self) -> Result<u64, Error>[src]

Returns the current seek position from the start of the stream. Read more

fn read_exact_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<(), Error>[src]

Is to read_vectored what read_exact is to read.

fn write_all_vectored(&self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>[src]

Is to write_vectored what write_all is to write.

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T> FromUnsafeFile for T where
    T: FromRawHandle + OwnsRaw, [src]

pub unsafe fn from_unsafe_file(unsafe_file: UnsafeFile) -> T[src]

Convert an unsafe file into a Self. Read more

fn from_filelike<Filelike>(filelike: Filelike) -> Self where
    Filelike: IntoUnsafeFile, [src]

Convert from a type which implements IntoUnsafeFile into a type that implements FromUnsafeFile. Read more

impl<T> GetSetFdFlags for T where
    T: AsUnsafeFile + FromUnsafeFile, [src]

pub fn get_fd_flags(&self) -> Result<FdFlags, Error>[src]

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

pub fn set_fd_flags(&mut self, fd_flags: FdFlags) -> Result<(), Error>[src]

Set the “status” flags for the self file descriptor. On some platforms, this may close the file descriptor and produce a new one. Read more

impl<T> Instrument for T[src]

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

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

fn in_current_span(self) -> Instrumented<Self>[src]

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

impl<T, U> Into<U> for T where
    U: From<T>, [src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> IntoUnsafeFile for T where
    T: IntoRawHandle + IntoUnsafeHandle + OwnsRaw, [src]

pub fn into_unsafe_file(self) -> UnsafeFile[src]

Convert self into an unsafe file.

impl<T> IntoUnsafeHandle for T where
    T: IntoRawHandleOrSocket + OwnsRaw, [src]

pub fn into_unsafe_handle(self) -> UnsafeHandle[src]

Convert self into an unsafe handle.

impl<T> Pointee for T

type Pointer = u32

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

impl<T> SetTimes for T where
    T: AsUnsafeFile, [src]

pub fn set_times(
    &self,
    atime: Option<SystemTimeSpec>,
    mtime: Option<SystemTimeSpec>
) -> Result<(), Error>[src]

Set the last access and last modification timestamps of an open file handle. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.

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

pub fn vzip(self) -> V