Module subset::unique

Subset of slice's items that is able to iterate forward and backward over mutable or immutable references to selected items. Each item of a slice can be selected no more than once.

Examples

use subset::unique::*;
 
// Constructing mutable subset
let mut set = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
let idxs = vec![10];
assert_eq!(SubsetMut::new(&mut set, &idxs).err(), Some(SubsetError::OutOfBounds));
let idxs = vec![2, 2, 5];
assert_eq!(SubsetMut::new(&mut set, &idxs).err(), Some(SubsetError::NotUnique));
let idxs = vec![2, 4, 7];   // Indexes of selected items
let mut subset = SubsetMut::new(&mut set, &idxs).unwrap();
 
// Iterating over mutable references
let mut iter = subset.iter_mut();
let r1 = iter.next().unwrap();
assert_eq!(*r1, 7);
let r2 = iter.next().unwrap();
assert_eq!(*r2, 5);
*r1 = 19;
*r2 = 33;
assert_eq!(iter.next(), Some(&mut 2));
assert_eq!(iter.next(), None);
assert_eq!(subset.set(), vec![9, 8, 19, 6, 33, 4, 3, 2, 1, 0].as_slice());
 
// Converting to immutable subset
let mut subset = SubsetMut::new(&mut set, &idxs).unwrap();
let imm_subset: Subset<_> = subset.into();
 
// Converting to mutable or immutable multi-subset
let mut subset = SubsetMut::new(&mut set, &idxs).unwrap();
let multi_subset: subset::multi::SubsetMut<_> = subset.into();
let mut subset = SubsetMut::new(&mut set, &idxs).unwrap();
let imm_multi_subset: subset::multi::Subset<_> = subset.into();

Re-exports

pub use super::SubsetError;

Structs

IterMut	Double-ended iterator over mutable references to selected items of set.
Subset	Subset of slice's items that is able to iterate forward and backward over immutable references to selected items. Each item of a slice can be selected no more than once.
SubsetMut	Subset of slice's items that is able to iterate forward and backward over mutable or immutable references to selected items. Each item of a slice can be selected no more than once.

Traits

From	Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.
Into	A value-to-value conversion that consumes the input value. The opposite of From.
TryFrom	Simple and safe type conversions that may fail in a controlled way under some circumstances. It is the reciprocal of TryInto.
TryInto	An attempted conversion that consumes self, which may or may not be expensive.