Struct chord2key::attribute_set::AttributeSet

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

An immutable set of tracked items

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

It allows for efficient, hashable subsets (AttributeSubset) of this set to be created and used for as long as this set is still around.

Examples:

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

It is a logic error for the AttributeSet or any of its items to be modified.

Implementations

impl<T: Hash + Eq> AttributeSet<T>

pub fn from_capacity<U>(set: U, capacity: usize) -> Rc<Self> where
    U: IntoIterator<Item = T>, 

Creates a new AttributeSet with a specified capacity for memory allocation

Example:

use chord2key::attribute_set::*;

let vec_set = vec![-9, -9, 7, 2, 5];
let size = vec_set.len();
let attr_set = AttributeSet::<i32>::from_capacity(vec_set, size);

pub fn from<U>(set: U) -> Rc<Self> where
    U: IntoIterator<Item = T>, 

Creates a new AttributeSet from a set U that contains items T for the AttributeSet.

Example:

use chord2key::attribute_set::*;

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

pub fn len(&self) -> usize

Returns the number of items that are contained in the AttributeSet.

Example:

use chord2key::attribute_set::*;

let vec_set = vec![5, 2, 4];
let attr_set = AttributeSet::<i32>::from(vec_set);
assert_eq!(attr_set.len(), 3);

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

Returns true if the set contains an 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 vec_set = vec![5, 2, 4];
let attr_set = AttributeSet::<i32>::from(vec_set);
assert_eq!(attr_set.contains(&4), true);
assert_eq!(attr_set.contains(&3), false);

pub fn empty_subset(self: &Rc<Self>) -> AttributeSubset<T>

Creates an empty AttributeSubset with this AttributeSet as its parent

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.empty_subset();

pub fn subset_with<U>(self: &Rc<Self>, items: U) -> AttributeSubset<T> where
    U: IntoIterator<Item = T>, 

Creates a prefilled AttributeSubset with this AttributeSet as its parent. Consumes the subset source collection.

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, 2]);
assert_eq!(subset.contains(&5), true);
assert_eq!(subset.contains(&2), true);
assert_eq!(subset.contains(&4), false);

pub fn subset_from<'a, U>(self: &Rc<Self>, items: U) -> AttributeSubset<T> where
    U: Iterator<Item = &'a T>,
    T: 'a, 

Creates a prefilled AttributeSubset with this AttributeSet as its parent. Does not consume the subset source collection.

Example:

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

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

let mut unhashable_subset = HashSet::<i32>::new();
unhashable_subset.insert(5);
unhashable_subset.insert(2);

let hashable_subset = attr_set.subset_from(unhashable_subset.iter());

assert_eq!(hashable_subset.contains(&5), true);
assert_eq!(hashable_subset.contains(&2), true);
assert_eq!(hashable_subset.contains(&4), false);

pub fn iter(&self) -> impl Iterator<Item = &T>

An iterator visiting all the items 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 sum: i32 = attr_set.iter().sum();
let max: i32 = *attr_set.iter().max().unwrap();
assert_eq!(sum, 5 + 2 + 4);
assert_eq!(max, 5);

Trait Implementations

impl<T: Clone> Clone for AttributeSet<T> where
    T: Hash + Eq, 

fn clone(&self) -> AttributeSet<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AttributeSet<T> where
    T: Hash + Eq, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

fn eq(&self, other: &AttributeSet<T>) -> bool

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

fn ne(&self, other: &AttributeSet<T>) -> bool

This method tests for !=.

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

impl<T> StructuralEq for AttributeSet<T> where
    T: Hash + Eq, 

impl<T> StructuralPartialEq for AttributeSet<T> where
    T: Hash + Eq,