Struct sdset::duo::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 two slices of different types.

Examples

use sdset::duo::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: 3, b: 10 },
])?;
let b = Set::new(&[1, 3, 4, 5]).unwrap();

// 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::new(a, b, f, g).difference();
let res: SetBuf<Foo> = op.into_set_buf();

assert_eq!(res.as_slice(), &[Foo{ a: 2, b: 9 }, Foo{ a: 2, b: 10 }][..]);

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(a: &'a Set<T>, b: &'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.

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