Struct tea_core::prelude::OptIter

pub struct OptIter<'a, V: Vec1View<T>, T> {
    pub view: &'a V,
    pub item: PhantomData<T>,
}

Fields

view: &'a V

item: PhantomData<T>

Trait Implementations

impl<V: Vec1View<T>, T> GetLen for OptIter<'_, V, T>

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl<'a, 'b, V: Vec1View<T>, T: IsNone> IntoIterator for &'b OptIter<'a, V, T>

type Item = Option<<T as IsNone>::Inner>

The type of the elements being iterated over.

type IntoIter = Box<dyn TrustedLen<Item = Option<<T as IsNone>::Inner>> + 'b>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V: Vec1View<T>, T: IsNone + 'a> Slice<Option<<T as IsNone>::Inner>> for OptIter<'a, V, T>

where V::Output<'a>: TIter<T>,

type Output<'b> = Vec<Option<<T as IsNone>::Inner>> where Self: 'b, Option<T::Inner>: 'b

fn slice<'b>( &'b self, start: usize, end: usize, ) -> TResult<Cow<'a, Self::Output<'b>>>

where Option<T::Inner>: 'b,

impl<V: Vec1View<T>, T: IsNone> TIter<Option<<T as IsNone>::Inner>> for OptIter<'_, V, T>

fn titer<'a>( &'a self, ) -> TrustIter<impl TIterator<Item = Option<<T as IsNone>::Inner>>>

where Self: 'a,

fn map<'a, U, F>(&'a self, f: F) -> TrustIter<impl TIterator<Item = U>>

where F: FnMut(T) -> U, T: 'a,

impl<'a, T: IsNone + 'a, V: Vec1View<T>> Vec1View<Option<<T as IsNone>::Inner>> for OptIter<'a, V, T>

where for<'b> V::Output<'b>: TIter<T>,

unsafe fn uget(&self, index: usize) -> Option<T::Inner>

Get the value at the index

fn try_as_slice(&self) -> Option<&[T]>

fn iter_cast<'a, U>(&'a self) -> TrustIter<impl TIterator<Item = U>>

where T: 'a + Cast<U>,

fn opt_iter_cast<'a, U>(&'a self) -> TrustIter<impl TIterator<Item = Option<U>>>

where T: IsNone + 'a, <T as IsNone>::Inner: Cast<U>,

fn opt(&self) -> OptIter<'_, Self, T>

where T: IsNone, Self: Sized,

fn to_opt_iter<'a>( &'a self, ) -> TrustIter<impl TIterator<Item = Option<T::Inner>>>

where T: IsNone + 'a,

unsafe fn uvget(&self, index: usize) -> Option<T::Inner>

where T: IsNone,

if the value is valid, return it, otherwise return None

fn get(&self, index: usize) -> TResult<T>

fn vget(&self, index: usize) -> Option<T::Inner>

where T: IsNone,

fn rolling_custom_iter<U, F>( &self, window: usize, f: F, ) -> impl TrustedLen<Item = U>

where F: FnMut(Cow<'_, <Self as Slice<T>>::Output<'_>>) -> U,

Rolling and apply a custom funtion to each window, but it won’t collect result

fn rolling_custom<O: Vec1<OT>, OT: Clone, F>( &self, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where F: FnMut(Cow<'_, <Self as Slice<T>>::Output<'_>>) -> OT,

Rolling and apply a custom funtion to each window

fn rolling2_custom<O: Vec1<OT>, OT: Clone, V2, T2, F>( &self, other: &V2, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where V2: Vec1View<T2>, F: FnMut(&<Self as Slice<T>>::Output<'_>, &<V2 as Slice<T2>>::Output<'_>) -> OT,

Rolling and apply a custom funtion to each window of two vecs

fn rolling_apply<O: Vec1<OT>, OT, F>( &self, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where T: Clone, F: FnMut(Option<T>, T) -> OT,

Rolling and apply a function, the function accept whether to move element from the window and a value to be added to the window

fn rolling_apply_to<O: Vec1<OT>, OT, F>( &self, window: usize, f: F, out: O::UninitRefMut<'_>, )

where T: Clone, F: FnMut(Option<T>, T) -> OT,

Rolling and apply a function, the function accept whether to move element from the window and a value to be added to the window.

fn rolling2_apply<O: Vec1<OT>, OT, V2: Vec1View<T2>, T2, F>( &self, other: &V2, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where T: Clone, T2: Clone, F: FnMut(Option<(T, T2)>, (T, T2)) -> OT,

Rolling and apply a function to both vecs, the function accept whether to move element from the window and a value to be added to the window

fn rolling2_apply_to<O: Vec1<OT>, OT, V2: Vec1View<T2>, T2, F>( &self, other: &V2, window: usize, f: F, out: O::UninitRefMut<'_>, )

where F: FnMut(Option<(T, T2)>, (T, T2)) -> OT,

Rolling and apply a function to both vecs, the function accept whether to move element from the window and a value to be added to the window.

fn rolling_apply_idx<O: Vec1<OT>, OT, F>( &self, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where F: FnMut(Option<usize>, usize, T) -> OT,

fn rolling_apply_idx_to<O: Vec1<OT>, OT, F>( &self, window: usize, f: F, out: O::UninitRefMut<'_>, )

where F: FnMut(Option<usize>, usize, T) -> OT,

be careful to use this function as it will panic in polars backend. use rolling_apply_idx instead

fn rolling2_apply_idx<O: Vec1<OT>, OT, V2: Vec1View<T2>, T2, F>( &self, other: &V2, window: usize, f: F, out: Option<O::UninitRefMut<'_>>, ) -> Option<O>

where F: FnMut(Option<usize>, usize, (T, T2)) -> OT,

fn rolling2_apply_idx_to<O: Vec1<OT>, OT, V2: Vec1View<T2>, T2, F>( &self, other: &V2, window: usize, f: F, out: O::UninitRefMut<'_>, )

where F: FnMut(Option<usize>, usize, (T, T2)) -> OT,

be careful to use this function as it will panic in polars backend. use rolling2_apply_idx instead