Struct PinSet 

pub struct PinSet(/* private fields */);

A set of pins represented as a u16 bitmask (up to 16 pins).

Bit i is 1 when pin i is present in the set. The type is Copy and all operations are const-friendly where possible.

Construction

// Infallible, const-evaluable constructors:
let ten = PinSet::full::<10>();          // first 10 pins
let specific = PinSet::of([3, 5, 6, 9]); // pins by index
let span = PinSet::range(5, 10);         // pins 5..10

// Collect from an iterator:
let collected: PinSet = (0..5).collect();

Implementations

impl PinSet

pub const EMPTY: Self

The empty set (no pins).

pub const fn full<const N: u8>() -> Self

Creates a full pin set with the first N pins standing.

This is an infallible, const-evaluable constructor. The pin count is checked at compile time when used in a const context; exceeding 16 triggers a compile-time error.

let ten = PinSet::full::<10>();
assert_eq!(ten.count(), 10);

pub const fn of<const N: usize>(pins: [u8; N]) -> Self

Creates a PinSet containing exactly the given pin indices.

let ps = PinSet::of([0, 1, 2]);
assert_eq!(ps.count(), 3);
assert!(ps.contains(0) && ps.contains(1) && ps.contains(2));

pub const fn range(start: u8, end: u8) -> Self

Creates a PinSet with pin indices in the half-open range [start, end).

let ps = PinSet::range(3, 7);
assert_eq!(ps, PinSet::of([3, 4, 5, 6]));

pub const fn from_raw(bits: u16) -> Self

Creates a PinSet from a raw bitmask. No validation; caller must ensure the mask only uses bits 0..pin_count.

pub const fn to_raw(self) -> u16

Returns the underlying bitmask.

pub const fn count(self) -> u8

Returns the number of pins in the set.

pub const fn is_empty(self) -> bool

Returns true if the set contains no pins.

pub const fn contains(self, idx: u8) -> bool

Returns true if pin idx is in the set.

pub const fn is_disjoint(self, other: Self) -> bool

Returns true if self and other share no common pins.

pub const fn is_subset_of(self, other: Self) -> bool

Returns true if every pin in self is also in other.

pub const fn insert(self, idx: u8) -> Self

Adds a single pin to the set.

pub const fn remove(self, idx: u8) -> Self

Removes a single pin from the set.

pub const fn contains_all(self, other: Self) -> bool

Returns true if other is a subset of self (all bits in other are also set in self).

pub const fn difference(self, other: Self) -> Self

Set difference: pins in self that are not in other.

Also available via the - operator.

pub const fn intersection(self, other: Self) -> Self

Set intersection: pins in both self and other.

Also available via the & operator.

pub const fn union(self, other: Self) -> Self

Set union: pins in either self or other.

Also available via the | operator.

pub const fn complement_within<const N: u8>(self) -> Self

Complement within a given pin count: the pins in 0..N that are not in self.

let standing = PinSet::of([0, 1, 2]);
let knocked = standing.complement_within::<10>();
assert_eq!(knocked, PinSet::range(3, 10));

pub fn iter(self) -> PinSetIter

Iterate over the pin indices present in the set.

Trait Implementations

impl BitAnd for PinSet

Set intersection: a & b returns pins in both sets.

type Output = PinSet

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl BitAndAssign for PinSet

Set intersection assignment: a &= b.

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr for PinSet

Set union: a | b returns pins in either set.

type Output = PinSet

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOrAssign for PinSet

Set union assignment: a |= b.

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for PinSet

fn clone(&self) -> PinSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PinSet

impl Debug for PinSet

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

Formats the value using the given formatter.

impl Default for PinSet

fn default() -> PinSet

Returns the “default value” for a type.

impl Display for PinSet

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

Formats the value using the given formatter.

impl Eq for PinSet

impl Extend<u8> for PinSet

Extend a PinSet with additional pin indices.

fn extend<I: IntoIterator<Item = u8>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<u8> for PinSet

Collect pin indices into a PinSet.

let ps: PinSet = [0u8, 2, 4].into_iter().collect();
assert_eq!(ps, PinSet::of([0, 2, 4]));

fn from_iter<I: IntoIterator<Item = u8>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for PinSet

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for PinSet

type Item = u8

The type of the elements being iterated over.

type IntoIter = PinSetIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Not for PinSet

Bitwise complement: !a flips all 16 bits.

Note: this flips all 16 bits regardless of pin count. For a complement within a specific pin count, use complement_within.

type Output = PinSet

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl PartialEq for PinSet

fn eq(&self, other: &PinSet) -> 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 StructuralPartialEq for PinSet

impl Sub for PinSet

Set difference: a - b returns pins in a that are not in b.

type Output = PinSet

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign for PinSet

Set difference assignment: a -= b.

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.