struct TakeAnyWhileConsumer<'p, C, P> {
    base: C,
    predicate: &'p P,
    taking: &'p AtomicBool,
}
Expand description

//////////////////////////////////////////////////////////////////////// Consumer implementation

Fields§

§base: C§predicate: &'p P§taking: &'p AtomicBool

Trait Implementations§

source§

impl<'p, T, C, P> Consumer<T> for TakeAnyWhileConsumer<'p, C, P>
where C: Consumer<T>, P: Fn(&T) -> bool + Sync,

§

type Folder = TakeAnyWhileFolder<'p, <C as Consumer<T>>::Folder, P>

The type of folder that this consumer can be converted into.
§

type Reducer = <C as Consumer<T>>::Reducer

The type of reducer that is produced if this consumer is split.
§

type Result = <C as Consumer<T>>::Result

The type of result that this consumer will ultimately produce.
source§

fn split_at(self, index: usize) -> (Self, Self, Self::Reducer)

Divide the consumer into two consumers, one processing items 0..index and one processing items from index... Also produces a reducer that can be used to reduce the results at the end.
source§

fn into_folder(self) -> Self::Folder

Convert the consumer into a folder that can consume items sequentially, eventually producing a final result.
source§

fn full(&self) -> bool

Hint whether this Consumer would like to stop processing further items, e.g. if a search has been completed.
source§

impl<'p, T, C, P> UnindexedConsumer<T> for TakeAnyWhileConsumer<'p, C, P>
where C: UnindexedConsumer<T>, P: Fn(&T) -> bool + Sync,

source§

fn split_off_left(&self) -> Self

Splits off a “left” consumer and returns it. The self consumer should then be used to consume the “right” portion of the data. (The ordering matters for methods like find_first – values produced by the returned value are given precedence over values produced by self.) Once the left and right halves have been fully consumed, you should reduce the results with the result of to_reducer.
source§

fn to_reducer(&self) -> Self::Reducer

Creates a reducer that can be used to combine the results from a split consumer.

Auto Trait Implementations§

§

impl<'p, C, P> Freeze for TakeAnyWhileConsumer<'p, C, P>
where C: Freeze,

§

impl<'p, C, P> RefUnwindSafe for TakeAnyWhileConsumer<'p, C, P>

§

impl<'p, C, P> Send for TakeAnyWhileConsumer<'p, C, P>
where C: Send, P: Sync,

§

impl<'p, C, P> Sync for TakeAnyWhileConsumer<'p, C, P>
where C: Sync, P: Sync,

§

impl<'p, C, P> Unpin for TakeAnyWhileConsumer<'p, C, P>
where C: Unpin,

§

impl<'p, C, P> UnwindSafe for TakeAnyWhileConsumer<'p, C, P>

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

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.

source§

impl<T> IntoEither for T

source§

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

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

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

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

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

Initializes a with the given initializer. Read more
source§

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

Dereferences the given pointer. Read more
source§

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

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.