Struct chord2key::attribute_set::AttributeSubset

pub struct AttributeSubset<T> where
    T: Hash + Eq,  { /* fields omitted */ }

A compressed hashable, mutable subset of a specific AttributeSet.

This is analogous to a mutable heap-allocated subset of a constant heap-allocated std::collections::HashSet. As such, it requires its items to implement the Eq and Hash traits.

Example

use chord2key::attribute_set::*;
use std::collections::HashMap;
use std::rc::Rc;

#[derive(PartialEq, Eq, Hash)]
enum Letters {
    A, B, C, D
}

struct Combos {
    pub letters: Rc<AttributeSet<Letters>>,
    pub combo_map: HashMap<AttributeSubset<Letters>, i32>,
}

let mut combos = Combos {
    letters: AttributeSet::<Letters>::from(vec![Letters::A, Letters::B, Letters::C]),
    combo_map: HashMap::<AttributeSubset<Letters>, i32>::new(),
};

let combo_set1 = combos.letters.subset_with(vec![Letters::A, Letters::B]);
let combo_set2 = combos.letters.subset_with(vec![Letters::B, Letters::C]);
combos.combo_map.insert(combo_set1, 1);
combos.combo_map.insert(combo_set2, 2);

let combo_num = combos.combo_map.get(&combos.letters.subset_with(vec![Letters::B,Letters::C]));
assert_eq!(*combo_num.unwrap(), 2);

Note: the hashing and equality implementations depend on the subset being created from the same parent in memory, not a clone.

Example:

use chord2key::attribute_set::*;
use std::rc::Rc;

let set1 = AttributeSet::<i32>::from(vec![5, 9, 12]);
let set2 = AttributeSet::<i32>::from(vec![5, 9, 12]);

let subset1 = set1.subset_with(vec![5, 9]);
let subset2 = set2.subset_with(vec![5, 9]);
assert!(subset1 != subset2);

Implementations

impl<T> AttributeSubset<T> where
    T: Hash + Eq, 

pub fn try_insert(&mut self, item: &T) -> Result<(), &'static str>

Adds an item from the parent set to the subset

If the item was successfully added (part of the parent set), returns Ok.

If the item could not be added (not part of the parent set), returns an Error.

Example:

use chord2key::attribute_set::*;
use std::rc::Rc;

let attr_set = Rc::new(AttributeSet::<i32>::from(vec![5, 2, 4]));
let mut subset = attr_set.empty_subset();
assert!(subset.try_insert(&5).is_ok());
assert!(subset.try_insert(&3).is_err());

pub fn remove(&mut self, item: &T)

Removes an item from the subset

Example:

use chord2key::attribute_set::*;
use std::rc::Rc;

let attr_set = Rc::new(AttributeSet::<i32>::from(vec![5, 2, 4]));
let mut subset = attr_set.empty_subset();

subset.try_insert(&5).ok();
assert!(subset.contains(&5));

subset.remove(&5);
assert!(!subset.contains(&5));

pub fn contains(&self, item: &T) -> bool

Returns true if the set contains a item.

The item may be any borrowed form of the set’s item type, but Hash and Eq on the borrowed form must match those for the item type.

Example:

use chord2key::attribute_set::*;

let attr_set = AttributeSet::<i32>::from(vec![5, 2, 4]);
let mut subset = attr_set.empty_subset();
subset.try_insert(&5).ok();
assert_eq!(subset.contains(&5), true);  // Contained by both parent set and subset
assert_eq!(subset.contains(&4), false); // Contained by parent set but not subset
assert_eq!(subset.contains(&3), false); // Contained by neither parent set nor subset

pub fn clear(&mut self)

Clears the set, removing all items.

Example:

use chord2key::attribute_set::*;

let attr_set = AttributeSet::<i32>::from(vec![5, 2, 4]);
let mut subset = attr_set.subset_with(vec![5, 2]);
assert!(subset.contains(&5));
assert!(subset.contains(&2));

subset.clear();
assert!(!subset.contains(&5));
assert!(!subset.contains(&2));

pub fn items<'b>(&self) -> impl Iterator<Item = &T>

An iterator visiting all the items in the subset in arbitrary order.

Example:

use chord2key::attribute_set::*;
use std::rc::Rc;
let attr_set = Rc::new(AttributeSet::<i32>::from(vec![5, 2, 4]));
let subset = attr_set.subset_with(vec![5, 4]);

let sum: i32 = subset.items().sum();
assert_eq!(sum, 9);

let min: i32 = *subset.items().min().unwrap();
assert_eq!(min, 4);

pub fn copy_from(
    &mut self,
    other: &AttributeSubset<T>
) -> Result<(), &'static str>

Copies from a different AttributeSubset, returning a result if it was successful

Returns an error if the AttributeSubset has a different parent

Example:

use chord2key::attribute_set::*;
use std::rc::Rc;

let attr_set = Rc::new(AttributeSet::<i32>::from(vec![5, 2, 4]));

let subset1 = attr_set.subset_with(vec![5, 4]);
let mut subset2 = attr_set.empty_subset();

assert!(!subset2.contains(&5));
assert!(!subset2.contains(&4));

subset2.copy_from(&subset1);

assert!(subset2.contains(&5));
assert!(subset2.contains(&4));
assert!(!subset2.contains(&2));

Trait Implementations

impl<T> Hash for AttributeSubset<T> where
    T: Hash + Eq, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq<AttributeSubset<T>> for AttributeSubset<T> where
    T: Hash + Eq, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<T> Eq for AttributeSubset<T> where
    T: Hash + Eq,