Struct BitFlags 

pub struct BitFlags<T, U>(/* private fields */)
where
    U: ?Sized;

A type-safe set of flags stored in an integer T.

The second type parameter U is a tag type that distinguishes flag sets that share the same storage type. When U implements BitFlagsSpec, it defines which bits are valid.

BitFlags is #[repr(transparent)] over T, so it has the same layout as T.

Invalid bits

A BitFlags value is not guaranteed to contain only valid bits. BitFlags::from_bits_retain can create a value with any bit pattern of T, and raw-bit operations such as BitFlags::insert, BitFlags::toggle, BitFlags::union, and bitwise operators preserve invalid bits. Use BitFlags::truncate, BitFlags::try_from_bits, or BitFlags::from_bits_truncate when a value must be restricted to BitFlagsSpec::VALID_BITS_MASK.

BitFlags::bits returns the raw stored bits, including any invalid bits that are present.

Examples

use bitflags_lite::{BitFlags, BitFlagsSpec, NameMatcher};

struct PermissionsTag;

impl BitFlagsSpec<u32> for PermissionsTag {
    const VALID_BITS_MASK: u32 = (1 << 3) - 1;
    const FLAG_NAMES: &[&[&str]] = &[&["read"], &["write"], &["exec", "execute"]];
    const DEFAULT_NAME_MATCHER: NameMatcher = NameMatcher::Exact;
}

type Permissions = BitFlags<u32, PermissionsTag>;

const READ: Permissions = Permissions::try_from_bits(1 << 0).unwrap();
const WRITE: Permissions = Permissions::try_from_bits(1 << 1).unwrap();
const EXEC: Permissions = Permissions::try_from_bits(1 << 2).unwrap();

let rw = READ | WRITE;
assert!(rw.contains(READ));
assert!(rw.contains(WRITE));
assert!(!rw.contains(EXEC));

Method summary

• empty(): Return a set with no bits set.
• all_valid(): Return a set with all valid bits set.
• from_bits_retain(): Convert from raw bits without validation.
• from_bits_truncate(): Convert from raw bits, clearing invalid bits.
• try_from_bits(): Convert from raw bits, rejecting invalid bits.
• from_bit_retain(): Return a set with only the bit at a given index, without validation.
• from_bit_truncate(): Return a set with only the bit at a given index, clearing it if invalid.
• try_from_bit(): Return a set with only the bit at a given index, rejecting it if invalid.
• from_flag(): Convert from a single BitFlag.
• try_from_str(): Parse from a separated string.
• bits(): Return the raw stored bits.
• bits_mut(): Return a mutable reference to the raw bits.
• into_bits(): Consume the set and return the raw bits.
• iter(): Return an iterator over the set bits.
• is_empty(): Return true if no bits are set.
• is_valid(): Return true if all set bits are valid for the tag.
• intersects(): Return true if any bits are shared.
• contains(): Return true if all bits of another set are present.
• insert(): Add all bits of another set.
• remove(): Remove all bits of another set.
• toggle(): Flip all bits of another set.
• set(): Insert or remove bits based on a boolean.
• clear(): Remove all bits, valid and invalid.
• truncate(): Remove all invalid bits.
• intersection(): Return the bits set in both sets.
• union(): Return the bits set in either set.
• difference(): Return the bits set in self but not in other.
• symmetric_difference(): Return the bits set in exactly one set.
• complement(): Return the valid bits not set in self.

Implementations

impl<T, U> BitFlags<T, U>

where U: ?Sized,

pub const fn empty() -> Self

where T: IntOpsExt,

Creates a flag set with no bits set (zero bits).

This is equivalent to from_bits_retain(0).

pub const fn all_valid() -> Self

where U: BitFlagsSpec<T>,

Creates a flag set containing all valid bits for this tag.

This returns exactly BitFlagsSpec::VALID_BITS_MASK. Invalid bits are never set.

The method is named all_valid rather than all because a BitFlags value can contain invalid bits after BitFlags::from_bits_retain. In that case, “all” would be ambiguous: all bits of the storage type, all bits currently set, or all valid bits?

all_valid makes the meaning explicit.

pub const fn from_bits_retain(bits: T) -> Self

Creates a flag set from raw bits without validation.

The resulting value may contain bits not present in BitFlagsSpec::VALID_BITS_MASK. Such invalid bits are preserved by this constructor and by raw-bit operations unless an operation clears them, such as BitFlags::truncate, BitFlags::complement, BitFlags::from_bits_truncate, or Not.

pub const fn bits(&self) -> T

where T: Copy,

Returns the raw bits stored in this flag set.

The returned value may contain invalid bits if this value was created with BitFlags::from_bits_retain and has not since been passed through an operation that clears invalid bits, such as BitFlags::truncate or BitFlags::complement.

pub const fn bits_mut(&mut self) -> &mut T

Returns a mutable reference to the raw bits stored in this flag set.

Mutating the returned value can introduce invalid bits. Use BitFlags::truncate afterwards if the value must contain only valid bits.

pub fn into_bits(self) -> T

Consumes this flag set and returns the raw bits.

This is the consuming counterpart to BitFlags::bits. Like BitFlags::bits, the returned value may contain bits not present in BitFlagsSpec::VALID_BITS_MASK.

This method does not require T: Copy, so it is available for storage types that are not Copy.

pub const fn iter(self) -> BitFlagsIter<T, U>

where T: Copy + Not<Output = T> + BitAndAssign<T> + IntOpsExt,

Returns an iterator over the individual set bits in this flag set.

The iterator yields BitFlag values from the least significant bit to the most significant bit. It includes invalid bits if they are present.

pub fn try_from_str( input: &str, separator: &'static str, name_matcher: NameMatcher, ) -> Result<Self, BitFlagsParseError>

where T: BitOrAssign<T> + IntOpsExt, U: BitFlagsSpec<T>,

Parses a flag set from a string.

The input may be empty, which returns BitFlags::empty. Otherwise it is split on given separator, and each part is trimmed and matched against the names in BitFlagsSpec::FLAG_NAMES. Match behavior is specified by name_matcher. A part may also be a hexadecimal flag with a 0x prefix.

This method does not validate or truncate the parsed bits against BitFlagsSpec::VALID_BITS_MASK. The returned value may contain invalid bits.

Note that if separator is an empty string, the method would split into individual characters, which is almost certainly not intended.

Errors

Returns BitFlagsParseError if input is not a separator-separated list of named flags or hexadecimal flags.

impl<U> BitFlags<u8, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<u8, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<u8>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<u8>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: u8) -> Option<Self>

where U: BitFlagsSpec<u8>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: u8) -> Self

where U: BitFlagsSpec<u8>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<u8>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<u8>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<u8>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<u16, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<u16, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<u16>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<u16>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: u16) -> Option<Self>

where U: BitFlagsSpec<u16>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

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

where U: BitFlagsSpec<u16>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<u16>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<u16>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<u16>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<u32, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<u32, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<u32>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<u32>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: u32) -> Option<Self>

where U: BitFlagsSpec<u32>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: u32) -> Self

where U: BitFlagsSpec<u32>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<u32>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<u32>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<u32>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<u64, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<u64, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<u64>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<u64>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: u64) -> Option<Self>

where U: BitFlagsSpec<u64>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: u64) -> Self

where U: BitFlagsSpec<u64>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<u64>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<u64>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<u64>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<u128, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<u128, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<u128>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<u128>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: u128) -> Option<Self>

where U: BitFlagsSpec<u128>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: u128) -> Self

where U: BitFlagsSpec<u128>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<u128>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<u128>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<u128>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<usize, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<usize, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<usize>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<usize>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: usize) -> Option<Self>

where U: BitFlagsSpec<usize>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: usize) -> Self

where U: BitFlagsSpec<usize>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<usize>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<usize>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<usize>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<i8, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<i8, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<i8>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<i8>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: i8) -> Option<Self>

where U: BitFlagsSpec<i8>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: i8) -> Self

where U: BitFlagsSpec<i8>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<i8>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<i8>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<i8>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<i16, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<i16, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<i16>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<i16>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: i16) -> Option<Self>

where U: BitFlagsSpec<i16>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: i16) -> Self

where U: BitFlagsSpec<i16>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<i16>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<i16>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<i16>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<i32, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<i32, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<i32>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<i32>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: i32) -> Option<Self>

where U: BitFlagsSpec<i32>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: i32) -> Self

where U: BitFlagsSpec<i32>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<i32>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<i32>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<i32>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<i64, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<i64, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<i64>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<i64>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: i64) -> Option<Self>

where U: BitFlagsSpec<i64>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: i64) -> Self

where U: BitFlagsSpec<i64>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<i64>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<i64>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<i64>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<i128, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<i128, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<i128>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<i128>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: i128) -> Option<Self>

where U: BitFlagsSpec<i128>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: i128) -> Self

where U: BitFlagsSpec<i128>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<i128>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<i128>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<i128>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

impl<U> BitFlags<isize, U>

where U: ?Sized,

pub const fn from_flag(flag: BitFlag<isize, U>) -> Self

Creates a flag set from a single BitFlag.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit.

If the flag’s index is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_retain(bit: u8) -> Self

Creates a flag set with only the bit at index bit set.

The bit index is not validated against BitFlagsSpec::VALID_BITS_MASK. The resulting value may contain an invalid bit. Use BitFlags::try_from_bit or BitFlags::from_bits_truncate when validation or truncation is required.

If bit is outside the width of T, the result is BitFlags::empty.

pub const fn from_bit_truncate(bit: u8) -> Self

where U: BitFlagsSpec<isize>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

This is the bit-index counterpart to BitFlags::from_bits_truncate. If bit is outside the width of T, or if the corresponding bit is not present in BitFlagsSpec::VALID_BITS_MASK, the result is BitFlags::empty.

The result always contains either exactly one bit or no bits.

Use BitFlags::try_from_bit when the caller needs to distinguish a valid index from an invalid one.

pub const fn try_from_bit(bit: u8) -> Option<Self>

where U: BitFlagsSpec<isize>,

Creates a flag set from bit index bit if that bit is valid.

Returns None if bit is outside the width of T or if the resulting bit is not present in BitFlagsSpec::VALID_BITS_MASK.

pub const fn try_from_bits(bits: isize) -> Option<Self>

where U: BitFlagsSpec<isize>,

Creates a flag set from raw bits if all set bits are valid.

Returns None if bits contains any bit not present in BitFlagsSpec::VALID_BITS_MASK.

Use BitFlags::from_bits_retain to keep invalid bits, or BitFlags::from_bits_truncate to clear them.

pub const fn from_bits_truncate(bits: isize) -> Self

where U: BitFlagsSpec<isize>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

This always succeeds and never stores invalid bits.

pub const fn is_empty(&self) -> bool

Returns true if no bits are set.

This checks the raw stored bits. A value containing only invalid bits is not empty.

pub const fn is_valid(&self) -> bool

where U: BitFlagsSpec<isize>,

Returns true if all set bits in self are valid for this tag.

A BitFlags value can contain bits not present in BitFlagsSpec::VALID_BITS_MASK after construction with BitFlags::from_bits_retain or after raw-bit operations such as BitFlags::insert, BitFlags::toggle, and BitFlags::union. This method returns false for such values.

Use BitFlags::truncate or BitFlags::from_bits_truncate to restrict a value to its valid bits.

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

Returns true if self and other have at least one set bit in common.

This compares raw bits. Invalid bits participate in the comparison if they are present.

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

Returns true if all bits set in other are also set in self.

This compares raw bits. Invalid bits participate in the comparison if they are present.

pub const fn insert(&mut self, other: Self)

Inserts all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Inserting other can introduce invalid bits into self.

pub const fn clear(&mut self)

Removes all bits from self, including any invalid bits.

This is equivalent to assigning BitFlags::empty to self.

pub const fn truncate(&mut self)

where U: BitFlagsSpec<isize>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

This leaves self unchanged if it already contains only valid bits.

pub const fn remove(&mut self, other: Self)

Removes all bits from other.

This is a raw-bit operation. It cannot introduce new bits, but it does not clear any other invalid bits that may already be present.

pub const fn toggle(&mut self, other: Self)

Toggles all bits from other.

This is a raw-bit operation. It does not validate or clear invalid bits. Toggling other can introduce invalid bits into self.

pub const fn set(&mut self, other: Self, value: bool)

Inserts other if value is true, or removes other if value is false.

This is a raw-bit operation and follows the same invalid-bit behavior as BitFlags::insert and BitFlags::remove.

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

Returns the intersection of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved when they are set in both operands.

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

Returns the union of self and other.

This is a raw-bit operation. Invalid bits in either operand are preserved.

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

Returns the difference of self and other.

The result contains bits that are set in self but not in other. This is a raw-bit operation. Invalid bits already present in self are preserved unless they are also set in other.

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

Returns the symmetric difference of self and other.

The result contains bits that are set in exactly one of self or other. This is a raw-bit operation. Invalid bits participate and may be preserved.

pub const fn complement(self) -> Self

where U: BitFlagsSpec<isize>,

Returns the complement of self.

All valid bits not set in self become set, and all invalid bits become unset. The result always contains only valid bits.

Trait Implementations

impl<'a, T, U> Arbitrary<'a> for BitFlags<T, U>

where T: Arbitrary<'a>, U: ?Sized,

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T, U> AsRef<T> for BitFlags<T, U>

where U: ?Sized,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, U> Binary for BitFlags<T, U>

where T: Binary, U: ?Sized,

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

Formats the value using the given formatter.

impl<T, U> BitAnd for BitFlags<T, U>

where T: BitAnd<T, Output = T>, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, U> BitAnd<BitFlag<T, U>> for BitFlags<T, U>

where T: BitAnd<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the & operator.

fn bitand(self, rhs: BitFlag<T, U>) -> Self::Output

Performs the & operation.

impl<T, U> BitAnd<BitFlags<T, U>> for BitFlag<T, U>

where T: BitAnd<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the & operator.

fn bitand(self, rhs: BitFlags<T, U>) -> Self::Output

Performs the & operation.

impl<T, U> BitAndAssign for BitFlags<T, U>

where T: BitAndAssign<T>, U: ?Sized,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T, U> BitAndAssign<BitFlag<T, U>> for BitFlags<T, U>

where T: BitAndAssign<T> + IntOpsExt, U: ?Sized,

fn bitand_assign(&mut self, rhs: BitFlag<T, U>)

Performs the &= operation.

impl<T, U> BitFlagsExt<T, U> for BitFlags<T, U>

where U: ?Sized,

fn from_flag(bit_flag: BitFlag<T, U>) -> Self

where T: IntOpsExt,

Creates a flag set from a single BitFlag.

fn from_bit_retain(bit: u8) -> Self

where T: IntOpsExt,

Creates a flag set with only the bit at index bit set.

fn from_bit_truncate(bit: u8) -> Self

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: BitFlagsSpec<T>,

Creates a flag set with only the bit at index bit set, clearing the bit if it is not valid for the tag.

fn try_from_bit(bit: u8) -> Option<Self>

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: BitFlagsSpec<T>,

Creates a flag set from bit index bit if that bit is valid.

fn try_from_bits(bits: T) -> Option<Self>

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: BitFlagsSpec<T>,

Creates a flag set from raw bits if all set bits are valid.

fn from_bits_truncate(bits: T) -> Self

where T: BitAnd<T, Output = T>, U: BitFlagsSpec<T>,

Creates a flag set from raw bits, clearing any bits not present in BitFlagsSpec::VALID_BITS_MASK.

fn is_empty(&self) -> bool

where T: Copy + PartialEq + IntOpsExt,

Returns true if no bits are set.

fn is_valid(&self) -> bool

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: BitFlagsSpec<T>,

Returns true if all set bits in self are valid for this tag.

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

where T: Copy + PartialEq + BitAnd<T, Output = T> + IntOpsExt,

Returns true if self and other have at least one set bit in common.

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

where T: Copy + PartialEq + BitAnd<T, Output = T>,

Returns true if all bits set in other are also set in self.

fn clear(&mut self)

where T: IntOpsExt,

Removes all bits from self, including any invalid bits.

fn truncate(&mut self)

where T: BitAndAssign<T>, U: BitFlagsSpec<T>,

Clears all bits not present in BitFlagsSpec::VALID_BITS_MASK.

fn insert(&mut self, other: Self)

where T: Copy + BitOrAssign<T>,

Inserts all bits from other.

fn remove(&mut self, other: Self)

where T: Copy + Not<Output = T> + BitAndAssign<T>,

Removes all bits from other.

fn toggle(&mut self, other: Self)

where T: Copy + BitXorAssign<T>,

Toggles all bits from other.

fn set(&mut self, other: Self, value: bool)

where T: Copy + Not<Output = T> + BitAndAssign<T> + BitOrAssign<T>,

Inserts other if value is true, or removes other if value is false.

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

where T: Copy + BitAnd<T, Output = T>,

Returns the intersection of self and other.

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

where T: Copy + BitOr<T, Output = T>,

Returns the union of self and other.

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

where T: Copy + Not<Output = T> + BitAnd<T, Output = T>,

Returns the difference of self and other.

fn symmetric_difference(self, other: Self) -> Self

where T: Copy + BitXor<T, Output = T>,

Returns the symmetric difference of self and other.

fn complement(self) -> Self

where T: Copy + Not<Output = T> + BitAnd<T, Output = T>, U: BitFlagsSpec<T>,

Returns the complement of self.

impl<T, U> BitOr for BitFlags<T, U>

where T: BitOr<T, Output = T>, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, U> BitOr<BitFlag<T, U>> for BitFlags<T, U>

where T: BitOr<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the | operator.

fn bitor(self, rhs: BitFlag<T, U>) -> Self::Output

Performs the | operation.

impl<T, U> BitOr<BitFlags<T, U>> for BitFlag<T, U>

where T: BitOr<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the | operator.

fn bitor(self, rhs: BitFlags<T, U>) -> Self::Output

Performs the | operation.

impl<T, U> BitOrAssign for BitFlags<T, U>

where T: BitOrAssign<T>, U: ?Sized,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T, U> BitOrAssign<BitFlag<T, U>> for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized,

fn bitor_assign(&mut self, rhs: BitFlag<T, U>)

Performs the |= operation.

impl<T, U> BitXor for BitFlags<T, U>

where T: BitXor<T, Output = T>, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T, U> BitXor<BitFlag<T, U>> for BitFlags<T, U>

where T: BitXor<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BitFlag<T, U>) -> Self::Output

Performs the ^ operation.

impl<T, U> BitXor<BitFlags<T, U>> for BitFlag<T, U>

where T: BitXor<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BitFlags<T, U>) -> Self::Output

Performs the ^ operation.

impl<T, U> BitXorAssign for BitFlags<T, U>

where T: BitXorAssign<T>, U: ?Sized,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T, U> BitXorAssign<BitFlag<T, U>> for BitFlags<T, U>

where T: BitXorAssign<T> + IntOpsExt, U: ?Sized,

fn bitxor_assign(&mut self, rhs: BitFlag<T, U>)

Performs the ^= operation.

impl<T, U> Borrow<T> for BitFlags<T, U>

where U: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, U> Clone for BitFlags<T, U>

where T: Clone, U: ?Sized,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U> Copy for BitFlags<T, U>

where T: Copy, U: ?Sized,

impl<T, U> Debug for BitFlags<T, U>

where T: LowerHex, U: ?Sized,

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

Formats the value using the given formatter.

impl<T, U> Default for BitFlags<T, U>

where T: Default, U: ?Sized,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T, U> Deserialize<'de> for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized + BitFlagsSpec<T>,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, U> Display for BitFlags<T, U>

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + Shl<usize, Output = T> + LowerHex + IntOpsExt, U: ?Sized + BitFlagsSpec<T>,

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

Formats the value using the given formatter.

impl<T, U> Eq for BitFlags<T, U>

where T: Eq, U: ?Sized,

impl<T, U> Extend<BitFlag<T, U>> for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = BitFlag<T, U>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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<T, U> Extend<BitFlags<T, U>> for BitFlags<T, U>

where T: BitOrAssign<T>, U: ?Sized,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Self>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

🔬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<T, U> From<BitFlag<T, U>> for BitFlags<T, U>

where T: IntOpsExt, U: ?Sized,

fn from(flag: BitFlag<T, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<i8, U>> for i8

where U: ?Sized,

fn from(flags: BitFlags<i8, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<i16, U>> for i16

where U: ?Sized,

fn from(flags: BitFlags<i16, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<i32, U>> for i32

where U: ?Sized,

fn from(flags: BitFlags<i32, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<i64, U>> for i64

where U: ?Sized,

fn from(flags: BitFlags<i64, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<i128, U>> for i128

where U: ?Sized,

fn from(flags: BitFlags<i128, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<isize, U>> for isize

where U: ?Sized,

fn from(flags: BitFlags<isize, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<u8, U>> for u8

where U: ?Sized,

fn from(flags: BitFlags<u8, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<u16, U>> for u16

where U: ?Sized,

fn from(flags: BitFlags<u16, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<u32, U>> for u32

where U: ?Sized,

fn from(flags: BitFlags<u32, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<u64, U>> for u64

where U: ?Sized,

fn from(flags: BitFlags<u64, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<u128, U>> for u128

where U: ?Sized,

fn from(flags: BitFlags<u128, U>) -> Self

Converts to this type from the input type.

impl<U> From<BitFlags<usize, U>> for usize

where U: ?Sized,

fn from(flags: BitFlags<usize, U>) -> Self

Converts to this type from the input type.

impl<T, U> FromIterator<BitFlag<T, U>> for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = BitFlag<T, U>>,

Creates a value from an iterator.

impl<T, U> FromIterator<BitFlags<T, U>> for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Self>,

Creates a value from an iterator.

impl<T, U> FromStr for BitFlags<T, U>

where T: BitOrAssign<T> + IntOpsExt, U: ?Sized + BitFlagsSpec<T>,

type Err = BitFlagsParseError

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T, U> Hash for BitFlags<T, U>

where T: Hash, U: ?Sized,

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<T, U> IntoIterator for BitFlags<T, U>

where T: Copy + Not<Output = T> + BitAndAssign<T> + IntOpsExt, U: ?Sized,

type IntoIter = BitFlagsIter<T, U>

Which kind of iterator are we turning this into?

type Item = BitFlag<T, U>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> IntoIterator for &BitFlags<T, U>

where T: Copy + Not<Output = T> + BitAndAssign<T> + IntOpsExt, U: ?Sized,

type IntoIter = BitFlagsIter<T, U>

Which kind of iterator are we turning this into?

type Item = BitFlag<T, U>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> IntoIterator for &mut BitFlags<T, U>

where T: Copy + Not<Output = T> + BitAndAssign<T> + IntOpsExt, U: ?Sized,

type IntoIter = BitFlagsIter<T, U>

Which kind of iterator are we turning this into?

type Item = BitFlag<T, U>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U> LowerHex for BitFlags<T, U>

where T: LowerHex, U: ?Sized,

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

Formats the value using the given formatter.

impl<T, U> Not for BitFlags<T, U>

where T: Not<Output = T> + BitAnd<T, Output = T>, U: ?Sized + BitFlagsSpec<T>,

type Output = BitFlags<T, U>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, U> Octal for BitFlags<T, U>

where T: Octal, U: ?Sized,

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

Formats the value using the given formatter.

impl<T, U> Ord for BitFlags<T, U>

where T: Ord, U: ?Sized,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<T, U> PartialEq for BitFlags<T, U>

where T: PartialEq, U: ?Sized,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, U> PartialEq<BitFlag<T, U>> for BitFlags<T, U>

where T: Copy + PartialEq + IntOpsExt, U: ?Sized,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, U> PartialEq<BitFlags<T, U>> for BitFlag<T, U>

where T: Copy + PartialEq + IntOpsExt, U: ?Sized,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, U> PartialOrd for BitFlags<T, U>

where T: PartialOrd, U: ?Sized,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<BitFlag<T, U>> for BitFlags<T, U>

where T: Copy + PartialOrd + IntOpsExt, U: ?Sized,

fn partial_cmp(&self, other: &BitFlag<T, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<BitFlags<T, U>> for BitFlag<T, U>

where T: Copy + PartialOrd + IntOpsExt, U: ?Sized,

fn partial_cmp(&self, other: &BitFlags<T, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> Pod for BitFlags<T, U>

where T: Pod, U: 'static + ?Sized,

Available on crate feature bytemuck only.

impl<T, U> Serialize for BitFlags<T, U>

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + Shl<usize, Output = T> + LowerHex + IntOpsExt, U: ?Sized + BitFlagsSpec<T>,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, U> Sub for BitFlags<T, U>

where T: Not<Output = T> + BitAnd<T, Output = T>, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, U> Sub<BitFlag<T, U>> for BitFlags<T, U>

where T: Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the - operator.

fn sub(self, rhs: BitFlag<T, U>) -> Self::Output

Performs the - operation.

impl<T, U> Sub<BitFlags<T, U>> for BitFlag<T, U>

where T: Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: ?Sized,

type Output = BitFlags<T, U>

The resulting type after applying the - operator.

fn sub(self, rhs: BitFlags<T, U>) -> Self::Output

Performs the - operation.

impl<T, U> SubAssign for BitFlags<T, U>

where T: Not<Output = T> + BitAndAssign<T>, U: ?Sized,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T, U> SubAssign<BitFlag<T, U>> for BitFlags<T, U>

where T: Not<Output = T> + BitAndAssign<T> + IntOpsExt, U: ?Sized,

fn sub_assign(&mut self, rhs: BitFlag<T, U>)

Performs the -= operation.

impl<T, U> TryFrom<BitFlags<T, U>> for BitFlag<T, U>

where T: Copy + PartialEq + Not<Output = T> + BitAnd<T, Output = T> + IntOpsExt, U: BitFlagsSpec<T>,

Converts a flag set into a single-bit flag.

This fails unless flags contains exactly one set bit and that bit is valid for the tag. See BitFlag::try_from_flags.

type Error = BitFlagFromFlagsError

The type returned in the event of a conversion error.

fn try_from(flags: BitFlags<T, U>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, U> UpperHex for BitFlags<T, U>

where T: UpperHex, U: ?Sized,

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

Formats the value using the given formatter.

impl<T, U> Zeroable for BitFlags<T, U>

where T: Zeroable, U: ?Sized,

Available on crate feature bytemuck only.

fn zeroed() -> Self

Calls zeroed.