Struct RcComparator

Source

pub struct RcComparator<T> { /* private fields */ }

Expand description

An Rc-based single-threaded comparator with shared ownership.

RcComparator wraps a comparator function in an Rc, providing single-threaded shared ownership semantics. It is cloneable and uses &self in composition operations.

§Type Parameters

T - The type of values being compared

§Examples

use prism3_function::comparator::{Comparator, RcComparator};
use std::cmp::Ordering;

let cmp = RcComparator::new(|a: &i32, b: &i32| a.cmp(b));
let cloned = cmp.clone();
assert_eq!(cmp.compare(&5, &3), Ordering::Greater);
assert_eq!(cloned.compare(&5, &3), Ordering::Greater);

§Author

Haixing Hu

Implementations§

Source §

impl<T: 'static> RcComparator<T>

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&T, &T) -> Ordering + 'static,

Creates a new RcComparator from a closure.

§Parameters

f - The closure to wrap

§Returns

A new RcComparator instance.

§Examples

use prism3_function::comparator::RcComparator;

let cmp = RcComparator::new(|a: &i32, b: &i32| a.cmp(b));

Source

pub fn reversed(&self) -> Self

Returns a comparator that imposes the reverse ordering.

§Returns

A new RcComparator that reverses the comparison order.

§Examples

use prism3_function::comparator::{Comparator, RcComparator};
use std::cmp::Ordering;

let cmp = RcComparator::new(|a: &i32, b: &i32| a.cmp(b));
let rev = cmp.reversed();
assert_eq!(rev.compare(&5, &3), Ordering::Less);
assert_eq!(cmp.compare(&5, &3), Ordering::Greater); // cmp still works

Source

pub fn then_comparing(&self, other: &Self) -> Self

Returns a comparator that uses this comparator first, then another comparator if this one considers the values equal.

§Parameters

other - The comparator to use for tie-breaking

§Returns

A new RcComparator that chains this comparator with another.

§Examples

use prism3_function::comparator::{Comparator, RcComparator};
use std::cmp::Ordering;

let cmp1 = RcComparator::new(|a: &i32, b: &i32| {
    (a % 2).cmp(&(b % 2))
});
let cmp2 = RcComparator::new(|a: &i32, b: &i32| a.cmp(b));
let chained = cmp1.then_comparing(&cmp2);
assert_eq!(chained.compare(&4, &2), Ordering::Greater);

Source

pub fn comparing<K, F>(key_fn: F) -> Self
where K: Ord, F: Fn(&T) -> &K + 'static,

Returns a comparator that compares values by a key extracted by the given function.

§Parameters

key_fn - A function that extracts a comparable key from values

§Returns

A new RcComparator that compares by the extracted key.

§Examples

use prism3_function::comparator::{Comparator, RcComparator};
use std::cmp::Ordering;

#[derive(Debug)]
struct Person {
    name: String,
    age: i32,
}

let by_age = RcComparator::comparing(|p: &Person| &p.age);
let p1 = Person { name: "Alice".to_string(), age: 30 };
let p2 = Person { name: "Bob".to_string(), age: 25 };
assert_eq!(by_age.compare(&p1, &p2), Ordering::Greater);

Source

pub fn into_fn(self) -> impl Fn(&T, &T) -> Ordering

Converts this comparator into a closure.

§Returns

A closure that implements Fn(&T, &T) -> Ordering.

§Examples

use prism3_function::comparator::{Comparator, RcComparator};
use std::cmp::Ordering;

let cmp = RcComparator::new(|a: &i32, b: &i32| a.cmp(b));
let func = cmp.into_fn();
assert_eq!(func(&5, &3), Ordering::Greater);