Enum SortOrder 

pub enum SortOrder {
    Asc,
    Desc,
}

Which way an order runs: ascending or descending.

use std::cmp::Ordering;
use kevy_text::SortOrder;
assert_eq!(SortOrder::Asc.apply(1.cmp(&2)), Ordering::Less);
assert_eq!(SortOrder::Desc.apply(1.cmp(&2)), Ordering::Greater);
assert_eq!(SortOrder::default(), SortOrder::Asc);

Variants

Asc

Smallest first.

// a "red shoe" 30, b "red hat" 10, c "red cap" 20
let price = |v: &[u8]| Some(v.to_vec());
let cheapest = QueryOpts::default().with_sort(Sort::new(0, &price).with_order(SortOrder::Asc));
let page = seg.matches_query_with(b"red", 2, cheapest);
assert_eq!(page.iter().map(|m| &m.key[..]).collect::<Vec<_>>(), [&b"b"[..], b"c"]);

Desc

Largest first.

// a "red shoe" 30, b "red hat" 10, c "red cap" 20
let price = |v: &[u8]| Some(v.to_vec());
let dearest = QueryOpts::default().with_sort(Sort::new(0, &price).with_order(SortOrder::Desc));
let page = seg.matches_query_with(b"red", 2, dearest);
assert_eq!(page.iter().map(|m| &m.key[..]).collect::<Vec<_>>(), [&b"a"[..], b"c"]);

Implementations

impl SortOrder

pub fn apply(self, ord: Ordering) -> Ordering

ord as this direction sees it: unchanged ascending, reversed descending.

use kevy_text::SortOrder;
let mut v = [3, 1, 2];
v.sort_by(|a, b| SortOrder::Desc.apply(a.cmp(b)));
assert_eq!(v, [3, 2, 1]);

Trait Implementations

impl Clone for SortOrder

fn clone(&self) -> SortOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SortOrder

impl Debug for SortOrder

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

Formats the value using the given formatter.

impl Default for SortOrder

fn default() -> SortOrder

Returns the “default value” for a type.

impl Eq for SortOrder

impl Hash for SortOrder

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SortOrder

fn eq(&self, other: &SortOrder) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SortOrder