Struct ExactlyOneError

pub struct ExactlyOneError<I>
where
    I: Iterator, { /* private fields */ }

Iterator returned for the error case of Itertools exactly_one() and at_most_one(). This iterator yields exactly the same elements as the input iterator.

During the execution of exactly_one the iterator must be mutated. This wrapper effectively "restores" the state of the input iterator when it's handed back.

This is very similar to PutBackN except this iterator only supports 0-2 elements and does not use a Vec.

Trait Implementations

impl<I> Clone for ExactlyOneError<I> where I: Iterator + Clone, I::Item: Clone,

fn clone(&self) -> ExactlyOneError<I>

impl<I> Debug for ExactlyOneError<I> where I: Iterator + Debug, I::Item: Debug,

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

impl<I> Display for ExactlyOneError<I> where I: Iterator,

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

impl<I> Error for ExactlyOneError<I> where I: Iterator + Debug, I::Item: Debug,

impl<I> ExactSizeIterator for ExactlyOneError<I> where I: ExactSizeIterator,

impl<I> Iterator for ExactlyOneError<I> where I: Iterator,

type Item = <I as Iterator>::Item;
fn next(&mut self) -> Option<Self::Item>
fn size_hint(&self) -> (usize, Option<usize>)
fn count(self) -> usize
where
    Self: Sized,
fn fold<B, F>(self, init: B, f: F) -> B
where
    F: FnMut(B, Self::Item) -> B,

Auto Trait Implementations

impl<I> Freeze for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: Freeze, I: Freeze,

impl<I> RefUnwindSafe for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: RefUnwindSafe, I: RefUnwindSafe,

impl<I> Send for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: Send, I: Send,

impl<I> Sync for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: Sync, I: Sync,

impl<I> Unpin for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: Unpin, I: Unpin,

impl<I> UnsafeUnpin for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: UnsafeUnpin, I: UnsafeUnpin,

impl<I> UnwindSafe for ExactlyOneError<I> where Option<Either<[<I as Iterator>::Item; 2], <I as Iterator>::Item>>: UnwindSafe, I: UnwindSafe,

Blanket Implementations

impl<I> IntoIterator for ExactlyOneError<I> where I: Iterator,

type Item = <I as Iterator>::Item;
type IntoIter = I;
fn into_iter(self) -> I

impl<IT> MultiUnzip<()> for ExactlyOneError<I> where IT: Iterator<Item = ()>,

fn multiunzip(self)

impl<IT, A, FromA> MultiUnzip<(FromA,)> for ExactlyOneError<I> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,

fn multiunzip(self) -> (FromA,)

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>,

fn multiunzip(self) -> (FromA, FromB)

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>,

fn multiunzip(self) -> (FromA, FromB, FromC)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ExactlyOneError<I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend<I>, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> CloneToUninit for ExactlyOneError<I> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for ExactlyOneError<I>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoEither for ExactlyOneError<I>

impl<T> Itertools for ExactlyOneError<I> where T: Iterator + ?Sized,

impl<T> ToOwned for ExactlyOneError<I> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T> ToString for ExactlyOneError<I> where T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> Into<U> for ExactlyOneError<I> 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 ExactlyOneError<I> where U: Into<T>,

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

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

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