Struct sdset::multi::DifferenceByKey

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

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 }]);

Methods

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, 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_vec(self, output: &mut Vec<T>)

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

fn into_set_buf(self) -> SetBuf<T>

Create a SetBuf using the SetOperation::extend_vec method.

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_vec(self, output: &mut Vec<&'a T>)

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

fn into_set_buf(self) -> SetBuf<T>

Create a SetBuf using the SetOperation::extend_vec method.

impl<'a, T: Clone + 'a, U: Clone + 'a, F: Clone, G: Clone, K: Clone> Clone for DifferenceByKey<'a, T, U, F, G, K> where
    F: Fn(&T) -> K,
    G: Fn(&U) -> K,
    K: Ord, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.