Struct abi_stable::sabi_types::bitarray::BitArray64

pub struct BitArray64<E> { /* private fields */ }

An array of 64 binary enum values.

Example

use abi_stable::sabi_types::bitarray::{BitArray64, BooleanEnum};

assert!(SET.at(0).is_even());
assert!(SET.at(1).is_odd());
assert!(SET.at(20).is_even());
assert!(SET.at(21).is_odd());




static SET: BitArray64<IsEven> = {
    let mut set = BitArray64::empty();

    let mut i = 0;
    while i < 64 {
        set = set.set(i, IsEven::Yes);
        i += 2;
    }

    set
};


#[derive(Debug, Copy, Clone)]
#[repr(u8)]
enum IsEven {
    No,
    Yes,
}

unsafe impl BooleanEnum for IsEven {
    const FALSE: Self = Self::No;
    const TRUE: Self = Self::Yes;
}

impl IsEven {
    pub const fn is_even(self) -> bool {
        matches!(self, IsEven::Yes)
    }
    pub const fn is_odd(self) -> bool {
        matches!(self, IsEven::No)
    }
}

Implementations

impl<E> BitArray64<E>

pub const fn with_count(count: usize) -> Self

where E: BooleanEnum,

Creates a BitArray64 where the first count elements are truthy.

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

Creates a BitArray64 from a u64.

pub const fn empty() -> Self

Creates a BitArray64 where all elements are falsy.

impl<E> BitArray64<E>

pub const fn at(self, index: usize) -> E

where E: BooleanEnum,

Gets the value of E at index

Panics

This function panics if index >= 64

pub const fn set(self, index: usize, value: E) -> Self

where E: BooleanEnum,

Sets the value at index to value

Panics

This function panics if index >= 64

impl<E> BitArray64<E>

pub const fn truncated(self, length: usize) -> Self

Truncates self so that only the first length elements are truthy.

pub const fn bits(self) -> u64

Converts this array to its underlying representation

pub fn iter(self) -> BitArray64Iter<E>

An iterator over the first count elements of the array.

pub fn eq(self, other: Self, count: usize) -> bool

Whether this array is equal to other up to the count element.

Trait Implementations

impl<E> Clone for BitArray64<E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E> Debug for BitArray64<E>

where E: BooleanEnum,

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

Formats the value using the given formatter.

impl<E> GetStaticEquivalent_ for BitArray64<E>

where E: __StableAbi,

type StaticEquivalent = _static_BitArray64<<E as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

impl<E: PartialEq> PartialEq for BitArray64<E>

fn eq(&self, other: &BitArray64<E>) -> bool

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

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

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

impl<E> StableAbi for BitArray64<E>

where E: __StableAbi,

type IsNonZeroType = <u64 as StableAbi>::IsNonZeroType

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<E> Copy for BitArray64<E>

impl<E: Eq> Eq for BitArray64<E>

impl<E> StructuralPartialEq for BitArray64<E>