Struct ReadDir

pub struct ReadDir(/* private fields */);

Expand description

A stream of entries in a directory.

This stream is returned by read_dir() and yields items of type io::Result<DirEntry>. Each DirEntry can then retrieve information like entry’s path or metadata.

Trait Implementations§

§

impl Debug for ReadDir

§

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

Formats the value using the given formatter. Read more

§

impl Stream for ReadDir

§

type Item = Result<DirEntry, Error>

Values yielded by the stream.

§

fn poll_next( self: Pin<&mut ReadDir>, cx: &mut Context<'_>, ) -> Poll<Option<<ReadDir as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted. Read more

§

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream. Read more

Auto Trait Implementations§

§

Struct ReadDirCopy item path

Trait Implementations§

impl Debug for ReadDir

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

impl Stream for ReadDir

type Item = Result<DirEntry, Error>

fn poll_next( self: Pin<&mut ReadDir>, cx: &mut Context<'_>, ) -> Poll<Option<<ReadDir as Stream>::Item>>

fn size_hint(&self) -> (usize, Option<usize>)

Auto Trait Implementations§

impl Freeze for ReadDir

impl RefUnwindSafe for ReadDir

impl Send for ReadDir

impl Sync for ReadDir

impl Unpin for ReadDir

impl UnwindSafe for ReadDir

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

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

fn in_current_span(self) -> Instrumented<Self>

impl<T> Instrument for T

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

fn in_current_span(self) -> Instrumented<Self>

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

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<S> StreamExt for Swhere S: Stream + ?Sized,

fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where Self: Unpin,

fn next(&mut self) -> NextFuture<'_, Self>where Self: Unpin,

fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>where Self: Stream<Item = Result<T, E>> + Unpin,

fn count(self) -> CountFuture<Self>where Self: Sized,

fn map<T, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> T,

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: Stream, F: FnMut(Self::Item) -> U,

fn flatten(self) -> Flatten<Self>where Self: Sized, Self::Item: Stream,

fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>where Self: Sized, F: FnMut(Self::Item) -> Fut, Fut: Future,

fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<T>,

fn take(self, n: usize) -> Take<Self>where Self: Sized,

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn skip(self, n: usize) -> Skip<Self>where Self: Sized,

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,

fn chain<U>(self, other: U) -> Chain<Self, U>where Self: Sized, U: Stream<Item = Self::Item>,

fn cloned<'a, T>(self) -> Cloned<Self>where Self: Sized + Stream<Item = &'a T>, T: Clone + 'a,

fn copied<'a, T>(self) -> Copied<Self>where Self: Sized + Stream<Item = &'a T>, T: Copy + 'a,

fn collect<C>(self) -> CollectFuture<Self, C>where Self: Sized, C: Default + Extend<Self::Item>,

fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>where Self: Sized + Stream<Item = Result<T, E>>, C: Default + Extend<T>,

fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>where Self: Sized, B: Default + Extend<Self::Item>, P: FnMut(&Self::Item) -> bool,

fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>where Self: Sized, F: FnMut(T, Self::Item) -> T,

fn try_fold<T, E, F, B>( &mut self, init: B, f: F, ) -> TryFoldFuture<'_, Self, F, B>where Self: Sized + Stream<Item = Result<T, E>> + Unpin, F: FnMut(B, T) -> Result<B, E>,

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

fn fuse(self) -> Fuse<Self>where Self: Sized,

fn cycle(self) -> Cycle<Self>where Self: Sized + Clone,

fn enumerate(self) -> Enumerate<Self>where Self: Sized,

fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),

fn nth(&mut self, n: usize) -> NthFuture<'_, Self>where Self: Unpin,

fn last(self) -> LastFuture<Self>where Self: Sized,

fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P>where Self: Unpin, P: FnMut(&Self::Item) -> bool,

fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>where Self: Unpin, F: FnMut(Self::Item) -> Option<B>,

fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>where Self: Unpin, P: FnMut(Self::Item) -> bool,

fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P>where Self: Unpin, P: FnMut(Self::Item) -> bool,

fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P>where Self: Unpin, P: FnMut(Self::Item) -> bool,

Struct ReadDir

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

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

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

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

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<S> StreamExt for S
where S: Stream + ?Sized,

fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
where Self: Unpin,

fn next(&mut self) -> NextFuture<'_, Self>
where Self: Unpin,

fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>
where Self: Stream<Item = Result<T, E>> + Unpin,

fn count(self) -> CountFuture<Self>
where Self: Sized,

fn map<T, F>(self, f: F) -> Map<Self, F>
where Self: Sized, F: FnMut(Self::Item) -> T,

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where Self: Sized, U: Stream, F: FnMut(Self::Item) -> U,

fn flatten(self) -> Flatten<Self>
where Self: Sized, Self::Item: Stream,

fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
where Self: Sized, F: FnMut(Self::Item) -> Fut, Fut: Future,

fn filter<P>(self, predicate: P) -> Filter<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
where Self: Sized, F: FnMut(Self::Item) -> Option<T>,

fn take(self, n: usize) -> Take<Self>
where Self: Sized,

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,

fn chain<U>(self, other: U) -> Chain<Self, U>
where Self: Sized, U: Stream<Item = Self::Item>,

fn cloned<'a, T>(self) -> Cloned<Self>
where Self: Sized + Stream<Item = &'a T>, T: Clone + 'a,

fn copied<'a, T>(self) -> Copied<Self>
where Self: Sized + Stream<Item = &'a T>, T: Copy + 'a,

fn collect<C>(self) -> CollectFuture<Self, C>
where Self: Sized, C: Default + Extend<Self::Item>,

fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>
where Self: Sized + Stream<Item = Result<T, E>>, C: Default + Extend<T>,

fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>
where Self: Sized, B: Default + Extend<Self::Item>, P: FnMut(&Self::Item) -> bool,

fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>
where Self: Sized, F: FnMut(T, Self::Item) -> T,

fn try_fold<T, E, F, B>( &mut self, init: B, f: F, ) -> TryFoldFuture<'_, Self, F, B>
where Self: Sized + Stream<Item = Result<T, E>> + Unpin, F: FnMut(B, T) -> Result<B, E>,

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

fn fuse(self) -> Fuse<Self>
where Self: Sized,

fn cycle(self) -> Cycle<Self>
where Self: Sized + Clone,

fn enumerate(self) -> Enumerate<Self>
where Self: Sized,

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),

fn nth(&mut self, n: usize) -> NthFuture<'_, Self>
where Self: Unpin,

fn last(self) -> LastFuture<Self>
where Self: Sized,

fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P>
where Self: Unpin, P: FnMut(&Self::Item) -> bool,

fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>
where Self: Unpin, F: FnMut(Self::Item) -> Option<B>,

fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P>
where Self: Unpin, P: FnMut(Self::Item) -> bool,

fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P>
where Self: Unpin, P: FnMut(Self::Item) -> bool,

fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P>
where Self: Unpin, P: FnMut(Self::Item) -> bool,

fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>
where Self: Sized, F: FnMut(Self::Item),

fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>
where Self: Unpin, F: FnMut(Self::Item) -> Result<(), E>,

fn zip<U>(self, other: U) -> Zip<Self, U>
where Self: Sized, U: Stream,

fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>
where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,

fn or<S>(self, other: S) -> Or<Self, S>
where Self: Sized, S: Stream<Item = Self::Item>,

fn race<S>(self, other: S) -> Race<Self, S>
where Self: Sized, S: Stream<Item = Self::Item>,

fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
where Self: Sized + Send + 'a,

fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>
where Self: Sized + 'a,