Struct DifferenceByKey

pub struct DifferenceByKey<'a, T: 'a, U: 'a, F, G, K>
where
    F: Fn(&T) -> K,
    G: Fn(&U) -> K,
    K: Ord,
{ /* private fields */ }

Represent the difference set operation that will be applied to multiple slices of two different types.

Examples

use sdset::multi::OpBuilderByKey;
use sdset::{SetOperation, Set, SetBuf};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
struct Foo { a: i32, b: u8 }

let a = Set::new(&[
    Foo{ a: 1, b: 6 },
    Foo{ a: 1, b: 7 },
    Foo{ a: 1, b: 8 },
    Foo{ a: 2, b: 9 },
    Foo{ a: 2, b: 10 },
    Foo{ a: 4, b: 10 },
])?;
let b = Set::new(&[2, 3, 5, 7])?;
let c = Set::new(&[4, 6, 7])?;

// Return the field of Foo that will be used for comparison
let f = |x: &Foo| x.a;

// directly use the i32 for comparison
let g = |x: &i32| *x;

let op = OpBuilderByKey::from_vec(a, vec![b, c], f, g).difference();
let res: SetBuf<Foo> = op.into_set_buf();

assert_eq!(&res[..], &[Foo{ a: 1, b: 6 }, Foo{ a: 1, b: 7 }, Foo{ a: 1, b: 8 }]);

Implementations

impl<'a, T, U, F, G, K> DifferenceByKey<'a, T, U, F, G, K>

where F: Fn(&T) -> K, G: Fn(&U) -> K, K: Ord,

pub fn new(base: &'a Set<T>, others: Vec<&'a Set<U>>, f: F, g: G) -> Self

Construct one with slices checked to be sorted and deduplicated.

Trait Implementations

impl<'a, T: Clone + 'a, U: Clone + 'a, F, G, K> Clone for DifferenceByKey<'a, T, U, F, G, K>

where F: Fn(&T) -> K + Clone, G: Fn(&U) -> K + Clone, K: Ord + Clone,

fn clone(&self) -> DifferenceByKey<'a, T, U, F, G, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T, U, F, G, K> SetOperation<&'a T> for DifferenceByKey<'a, T, U, F, G, K>

where F: Fn(&T) -> K, G: Fn(&U) -> K, K: Ord,

fn extend_collection<C>(self, output: &mut C)

where C: Collection<&'a T>,

Extend a Collection with the values of the Sets using this set operation.

fn into_set_buf(self) -> SetBuf<T>

where T: Clone,

Create a SetBuf using the SetOperation::extend_collection method.

impl<'a, T, U, F, G, K> SetOperation<T> for DifferenceByKey<'a, T, U, F, G, K>

where T: Clone, F: Fn(&T) -> K, G: Fn(&U) -> K, K: Ord,

fn extend_collection<C>(self, output: &mut C)

where C: Collection<T>,

Extend a Collection with the values of the Sets using this set operation.

fn into_set_buf(self) -> SetBuf<T>

where T: Clone,

Create a SetBuf using the SetOperation::extend_collection method.