Struct Sorted

pub struct Sorted<C>(/* private fields */);

Struct to represent a sorted collection.

Implementations

impl<C> Sorted<C>

where C: Chain, C::Output: PartialOrd,

pub fn new(col: C) -> Result<Self, NotSorted>

Returns Some(Sorted) if collection is sorted, otherwise returns NotSorted Error.

impl<C> Sorted<C>

pub const fn new_unchecked(col: C) -> Self

Creates a sorted collection without checking if it is sorted.

As unsorted collection will not create UB but will probably panic at some point, such this function is still safe, even if an unsorted collection is given.

Trait Implementations

impl<C> Chain for Sorted<C>

where C: Chain,

fn len(&self) -> usize

Returns the minimum amount of elements the signal can create.

fn first(&self) -> Option<Self::Output>

Returns the first element of the signal, or None if it is empty.

fn last(&self) -> Option<Self::Output>

Returns the last element of the signal, or None if it is empty.

fn is_empty(&self) -> bool

Returns true if the signal does not generate any elements.

fn into_iter(self) -> IntoIter<Self>

where Self: Sized,

Convert signal to an iterator which steps through all generatable values.

fn iter(&self) -> IntoIter<&Self>

Create iterator which steps through all generatable values.

fn repeat(self) -> Repeat<Self>

where Self: Sized,

Transform signal to one which repeats its elements.

impl<C: Clone> Clone for Sorted<C>

fn clone(&self) -> Sorted<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for Sorted<C>

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

Formats the value using the given formatter.

impl<C, Idx> Index<Idx> for Sorted<C>

where C: Index<Idx>,

type Output = <C as Index<Idx>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<C: PartialEq> PartialEq for Sorted<C>

fn eq(&self, other: &Sorted<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C> Signal<usize> for Sorted<C>

where C: Signal<usize>,

type Output = <C as Signal<usize>>::Output

The element outputted

fn eval(&self, input: usize) -> Self::Output

Method to generate the element at the given input

fn extract<I, J>(self, iterator: I) -> Extract<Self, J>

where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to extract values from the interpolation.

fn stack<G>(self, signal: G) -> Stack<Self, G>

where Self: Sized,

Stack two signals together

fn composite<G>(self, signal: G) -> Composite<Self, G>

where Self: Sized,

Takes two signals and creates a new signal pipelining both signals.

fn by_ref(&self) -> &Self

Get a reference of the signal.

fn sample<I, J>(&self, iterator: I) -> Extract<&Self, J>

where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to sample values from the interpolation.

impl<C: Chain> SortedChain for Sorted<C>

fn strict_upper_bound_clamped( &self, element: Self::Output, min: usize, max: usize, ) -> usize

where Self::Output: PartialOrd + Copy,

Returns the smallest index between min and max for which the corresponding element is bigger then the input. If all elements are smaller, this function will return the given maximum.

fn strict_upper_bound(&self, element: Self::Output) -> usize

where Self::Output: PartialOrd + Copy,

Returns the smallest index for which the corresponding element is bigger then the input. If all elements are bigger, this function will return self.len().

fn upper_border(&self, element: Self::Output) -> (usize, usize, Self::Output)

where Self::Output: PartialOrd + Sub<Output = Self::Output> + Div<Output = Self::Output> + Zero + Copy + Debug,

Find the values inside the collection for which the given element is inbetween and a linear factor at how close it is to which value.

fn linear_factor_unchecked( &self, min_index: usize, max_index: usize, element: Self::Output, ) -> Self::Output

where Self::Output: Sub<Output = Self::Output> + Div<Output = Self::Output> + Copy,

Calculate the factor of element inbetween min and max.

fn linear_factor( &self, min_index: usize, max_index: usize, element: Self::Output, ) -> Self::Output

where Self::Output: Sub<Output = Self::Output> + Div<Output = Self::Output> + Zero + Copy,

Calculate the factor of element inbetween min and max.

impl<C: Copy> Copy for Sorted<C>

impl<C> StructuralPartialEq for Sorted<C>