Struct DirEntry

pub struct DirEntry { /* private fields */ }

Entries returned by the ReadDir stream.

This is a specialized version of std::fs::DirEntry for usage from the Tokio runtime.

An instance of DirEntry represents an entry inside of a directory on the filesystem. Each entry can be inspected via methods to learn about the full path or possibly other metadata through per-platform extension traits.

Implementations

impl DirEntry

fn path(&self) -> PathBuf

Returns the full path to the file that this entry represents.

The full path is created by joining the original path to read_dir with the filename of this entry.

Examples

use tokio::fs;

# async fn dox() -> std::io::Result<()> {
let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    println!("{:?}", entry.path());
}
# Ok(())
# }

This prints output like:

"./whatever.txt"
"./foo.html"
"./hello_world.rs"

The exact text, of course, depends on what files you have in ..

fn file_name(&self) -> OsString

Returns the bare file name of this directory entry without any other leading path component.

Examples

use tokio::fs;

# async fn dox() -> std::io::Result<()> {
let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    println!("{:?}", entry.file_name());
}
# Ok(())
# }

async fn metadata(&self) -> Result<Metadata>

Returns the metadata for the file that this entry points at.

This function will not traverse symlinks if this entry points at a symlink.

Platform-specific behavior

On Windows this function is cheap to call (no extra system calls needed), but on Unix platforms this function is the equivalent of calling symlink_metadata on the path.

Examples

use tokio::fs;

# async fn dox() -> std::io::Result<()> {
let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    if let Ok(metadata) = entry.metadata().await {
        // Now let's show our entry's permissions!
        println!("{:?}: {:?}", entry.path(), metadata.permissions());
    } else {
        println!("Couldn't get file type for {:?}", entry.path());
    }
}
# Ok(())
# }

async fn file_type(&self) -> Result<FileType>

Returns the file type for the file that this entry points at.

This function will not traverse symlinks if this entry points at a symlink.

Platform-specific behavior

On Windows and most Unix platforms this function is free (no extra system calls needed), but some Unix platforms may require the equivalent call to symlink_metadata to learn about the target file type.

Examples

use tokio::fs;

# async fn dox() -> std::io::Result<()> {
let mut entries = fs::read_dir(".").await?;

while let Some(entry) = entries.next_entry().await? {
    if let Ok(file_type) = entry.file_type().await {
        // Now let's show our entry's file type!
        println!("{:?}: {:?}", entry.path(), file_type);
    } else {
        println!("Couldn't get file type for {:?}", entry.path());
    }
}
# Ok(())
# }

impl DirEntry

fn ino(&self) -> u64

Returns the underlying d_ino field in the contained dirent structure.

Examples

use tokio::fs;

# #[tokio::main]
# async fn main() -> std::io::Result<()> {
let mut entries = fs::read_dir(".").await?;
while let Some(entry) = entries.next_entry().await? {
    // Here, `entry` is a `DirEntry`.
    println!("{:?}: {}", entry.file_name(), entry.ino());
}
# Ok(())
# }

Trait Implementations

impl Debug for DirEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

impl Freeze for DirEntry

impl RefUnwindSafe for DirEntry

impl Send for DirEntry

impl Sync for DirEntry

impl Unpin for DirEntry

impl UnsafeUnpin for DirEntry

impl UnwindSafe for DirEntry

Blanket Implementations

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for DirEntry where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for DirEntry where T: ?Sized,

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

impl<T> From<T> for DirEntry

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for DirEntry where U: From<T>,

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, U> TryFrom<U> for DirEntry where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for DirEntry where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>