Trait CurveIterator 

pub trait CurveIterator: Debug {
    type CurveKind: CurveType;

    // Required method
    fn next_window(
        &mut self,
    ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>;

    // Provided methods
    fn collect_curve<R: FromCurveIterator<Self::CurveKind>>(self) -> R
       where Self: Sized { ... }
    fn reclassify<O>(self) -> ReclassifyIterator<Self, O>
       where Self: Sized { ... }
    fn normalize(
        self,
    ) -> JoinAdjacentIterator<CurveIteratorIterator<Self>, <Self::CurveKind as CurveType>::WindowKind, Self::CurveKind>
       where Self: Sized { ... }
    fn take_while_curve<F>(
        self,
        fun: F,
    ) -> TakeWhile<CurveIteratorIterator<Self>, F>
       where Self: Sized,
             F: for<'a> FnMut(&'a Window<<Self::CurveKind as CurveType>::WindowKind>) -> bool { ... }
    fn fuse_curve(self) -> Fuse<CurveIteratorIterator<Self>>
       where Self: Sized { ... }
    fn into_iterator(self) -> CurveIteratorIterator<Self> 
       where Self: Sized { ... }
}

Trait representing an Iterator that has almost the guarantees of a curve:

1. Windows ordered by start
2. Windows non-overlapping or adjacent (this differs from Curves as it allows adjacent windows)
3. Windows non-empty

Or in other words all finite prefixes of the Iterator are a valid Curves

Required Associated Types

type CurveKind: CurveType

The type of the curve being iterated

Required Methods

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

calculate and returns the next window of the curve iterator advancing the iterator in the process

Provided Methods

fn collect_curve<R: FromCurveIterator<Self::CurveKind>>(self) -> R

where Self: Sized,

collect the iterator mirroring core::iter::Iterator::collect

fn reclassify<O>(self) -> ReclassifyIterator<Self, O>

where Self: Sized,

reclassify a CurveIterator

fn normalize( self, ) -> JoinAdjacentIterator<CurveIteratorIterator<Self>, <Self::CurveKind as CurveType>::WindowKind, Self::CurveKind>

where Self: Sized,

normalize the CurveIterator by combining adjacent windows

fn take_while_curve<F>( self, fun: F, ) -> TakeWhile<CurveIteratorIterator<Self>, F>

where Self: Sized, F: for<'a> FnMut(&'a Window<<Self::CurveKind as CurveType>::WindowKind>) -> bool,

Basically core::iter::Iterator::take_while but for CurveIterator

fn fuse_curve(self) -> Fuse<CurveIteratorIterator<Self>>

where Self: Sized,

Basically core::iter::Iterator::fuse but for CurveIterator

fn into_iterator(self) -> CurveIteratorIterator<Self>

where Self: Sized,

Wrap the CurveIterator to allow usage of standart Iterator adapters

Implementations on Foreign Types

impl<'b, C> CurveIterator for Box<dyn ClonableCurveIterator<'b, CurveKind = C>>

where C: CurveType,

type CurveKind = C

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

impl<CI: CurveIterator> CurveIterator for &mut CI

type CurveKind = <CI as CurveIterator>::CurveKind

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

impl<CI: CurveIterator> CurveIterator for Box<CI>

type CurveKind = <CI as CurveIterator>::CurveKind

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

impl<W> CurveIterator for Empty<Window<W>>

where W: WindowType,

type CurveKind = UnspecifiedCurve<W>

fn next_window(&mut self) -> Option<Window<W>>

impl<W, P, CI> CurveIterator for TakeWhile<CI, P>

where W: WindowType, P: for<'r> FnMut(&'r Window<W>) -> bool, CI: CurveIterator + Iterator<Item = Window<W>>, CI::CurveKind: CurveType<WindowKind = W>,

type CurveKind = <CI as CurveIterator>::CurveKind

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

impl<W: WindowType, CI> CurveIterator for Fuse<CI>

where CI: CurveIterator + Iterator<Item = Window<W>>, CI::CurveKind: CurveType<WindowKind = W>,

type CurveKind = <CI as CurveIterator>::CurveKind

fn next_window( &mut self, ) -> Option<Window<<Self::CurveKind as CurveType>::WindowKind>>

Implementors

impl CurveIterator for TaskDemandIterator

type CurveKind = TaskDemand

impl<AC, CDC> CurveIterator for ActualServerExecutionIterator<AC, CDC>

where AC: CurveIterator<CurveKind = UnconstrainedServerExecution>, CDC: CurveIterator, CDC::CurveKind: CurveType<WindowKind = Demand>,

type CurveKind = ActualServerExecution

impl<C, I> CurveIterator for IterCurveWrapper<I, C>

where Self: Debug, C: CurveType, I: Iterator<Item = Window<C::WindowKind>>,

type CurveKind = C

impl<C, I> CurveIterator for JoinAdjacentIterator<I, C::WindowKind, C>

where Self: Debug, C: CurveType, I: Iterator<Item = Window<C::WindowKind>>,

type CurveKind = C

impl<C: CurveType> CurveIterator for CurveIter<C>

type CurveKind = C

impl<I> CurveIterator for ConstrainedServerDemandIterator<I>

where I: CurveIterator<CurveKind = AggregatedServerDemand>,

type CurveKind = ConstrainedServerDemand

impl<I> CurveIterator for CurveIteratorIterator<I>

where I: CurveIterator,

type CurveKind = <I as CurveIterator>::CurveKind

impl<I, O> CurveIterator for ReclassifyIterator<I, O>

where I: CurveIterator, O: CurveType,

type CurveKind = O

impl<I, W> CurveIterator for AggregationIterator<I, W>

where I: CurveIterator, I::CurveKind: CurveType<WindowKind = W>, W: Debug,

type CurveKind = <I as CurveIterator>::CurveKind

impl<I: CurveIterator, C: CurveType> CurveIterator for InverseCurveIterator<I, C>

type CurveKind = C

impl<W, I, C> CurveIterator for CapacityCheckIterator<W, I, C>

where I: CurveIterator<CurveKind = C>, C: CurveType<WindowKind = W> + Debug, W: WindowType,

type CurveKind = C