Struct FlagVec 

pub struct FlagVec<N: FlagLength, I = usize>(/* private fields */);

A data structure an indexed collection of N bit bit-flag like objects Behaves like DefaultVec<u32> but only considers the last N bits

Use StaticFlagVec when N is known at compile time, or DynamicFlagVec if it isn’t

Implementations

impl FlagVec<u32>

pub fn new(flag_bit_len: u32) -> Self

impl<N: FlagLength, I: Into<usize>> FlagVec<N, I>

pub fn or_assign(&mut self, x: I, v: u32)

Equivalent to self.set(x, self.get(x) | v)

use default_vec2::StaticFlagVec;
let mut s: StaticFlagVec<4> = StaticFlagVec::default();
s.or_assign(0, 3);
assert_eq!(s.get(0), 3);
s.or_assign(0, 9);
assert_eq!(s.get(0), 11);

pub fn and_assign(&mut self, x: I, v: u32)

Equivalent to self.set(x, self.get(x) & v)

use default_vec2::StaticFlagVec;
let mut s: StaticFlagVec<4> = StaticFlagVec::default();
s.or_assign(0, 11);
s.and_assign(0, 5);
assert_eq!(s.get(0), 1);

pub fn set(&mut self, x: I, v: u32)

Sets the element and index x to the last N bits of v

use default_vec2::StaticFlagVec;
let mut s: StaticFlagVec<4> = StaticFlagVec::default();
s.set(0, 3);
assert_eq!(s.get(0), 3);
s.set(0, 9);
assert_eq!(s.get(0), 9);
s.set(0, 18);
assert_eq!(s.get(0), 2);

pub fn get(&self, x: I) -> u32

Returns the element and index x

pub fn get_reserve(&mut self, x: I) -> u32

Same as get but already reserves space for x

pub fn clear(&mut self)

Removes all elements from the set

pub fn capacity(&self) -> usize

pub fn iter(&self) -> impl Iterator<Item = u32> + '_

Iterate over the elements of self

use default_vec2::StaticFlagVec;
let mut s: StaticFlagVec<10> = StaticFlagVec::default();
s.set(0, 42);
s.set(2, 999);
s.set(3, 365);
let res: Vec<_> = s.iter().collect();
assert_eq!(&res[..4], [42, 0, 999, 365])

Trait Implementations

impl<N: FlagLength, I> Clone for FlagVec<N, I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: FlagLength, I: Into<usize>> Debug for FlagVec<N, I>

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

Formats the value using the given formatter.

impl<N: FlagLength, I> PartialEq for FlagVec<N, I>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: FlagLength, I> Eq for FlagVec<N, I>