Struct Sorted

pub struct Sorted<'a, T: 'a, O: 'a> { /* private fields */ }

Guarantees that the inner container is sorted in a specific order.

The Sortable trait is a requirement for all containers T being wrapped with Sorted<T> to enforce certain guarantees for operations that arent strictly read only (i.e creating iterators). See the documentation of Sortable for details. Sortable: trait.Sortable.html

Implementations

impl<'a, T, O> Sorted<'a, T, O>

pub fn as_inner(&self) -> &T

pub fn deref_inner<U>(&'a self) -> Sorted<'a, &U, O>

where U: ?Sized, T: Deref<Target = U>,

pub fn iter(&'a self) -> SortedIter<<&T as IntoIterator>::IntoIter, O>

where &'a T: IntoIterator,

pub fn from_iter<I>(iter: I) -> Sorted<'a, T, O>

where T: RetainsOrder + FromIterator<<T as Collection>::Item>, I: IntoIterator<Item = T::Item>, I::IntoIter: SortedIterator<Ordering = O>, <I as IntoIterator>::IntoIter: SortedIterator<Ordering = O>,

Builds a sorted collection of type T from a sorted iterator.

As the RetainsOrder trait is required to be implemented for T, it’s guaranteed that the order of the input iterator is preserved. Since the iterator must implement SortedIterator, you’ll safely get a sorted collection. Sortable: trait.Sortable.html

impl<'a, T, O> Sorted<'a, T, O>

where T: Sortable, O: SortOrder<T::Item>,

pub fn by_sorting(collection: T) -> Self

impl<'a, T, O> Sorted<'a, T, O>

where T: SearchableByOrder<O>, O: SortOrder<T::Item>,

pub fn search(&self, a: &T::Item) -> Result<usize, usize>

impl<'a, T, O> Sorted<'a, T, O>

where T: Sortable + SortedInsert<O>, O: SortOrder<T::Item>,

pub fn insert(&mut self, x: T::Item)

impl<'a, T, O> Sorted<'a, T, O>

pub fn as_ref<U>(&self) -> Sorted<'a, &U, O>

where T: AsRef<U>, U: ?Sized + RetainsOrder,

Similar to Option::as_ref. It’s mapping the inner type with AsRef.

Trait Implementations

impl<'a, T, O> Deref for Sorted<'a, T, O>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T, O> IntoIterator for Sorted<'a, T, O>

where T: IntoIterator<Item = <T as Collection>::Item> + Sortable,

type Item = <T as Collection>::Item

The type of the elements being iterated over.

type IntoIter = SortedIter<<T as IntoIterator>::IntoIter, O>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.