[−][src]Struct bitarray::BitArray

pub struct BitArray<B: BitsIn, NBits: Unsigned + NonZero> where
    NBits: Add<<B as BitsIn>::Output>,
    <NBits as Add<<B as BitsIn>::Output>>::Output: Sub<B1>,
    <<NBits as Add<<B as BitsIn>::Output>>::Output as Sub<B1>>::Output: Div<<B as BitsIn>::Output>,
    <<<NBits as Add<<B as BitsIn>::Output>>::Output as Sub<B1>>::Output as Div<<B as BitsIn>::Output>>::Output: ArrayLength<B>,  { /* fields omitted */ }

The bitarray type.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U10;

let mut bv = BitArray::<u32, U10>::from_elem(false);

// insert all primes less than 10
bv.set(2, true);
bv.set(3, true);
bv.set(5, true);
bv.set(7, true);
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// flip all values in bitarray, producing non-primes less than 10
bv.negate();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// reset bitarray to empty
bv.clear();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

Methods

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`pub fn new() -> Self`[src]

Creates an empty BitArray.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::new();

`pub fn from_elem(bit: bool) -> Self`[src]

Creates a BitArray, setting each element to bit.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U10;

let mut bv = BitArray::<u32, U10>::from_elem(false);
assert_eq!(BitArray::<u32, U10>::len(), 10);
for x in bv.iter() {
    assert_eq!(x, false);
}

`pub fn from_bytes(bytes: &[u8]) -> Self`[src]

Transforms a byte-array into a BitArray. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes true if equal to 1 or false if equal to 0.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b10100000, 0b00010010]);
assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false,
                    false, false, false, true,
                    false, false, true, false]));

`pub fn from_fn<F>(f: F) -> Self where F: FnMut(usize) -> bool,` [src]

Creates a BitArray of the specified length where the value at each index is f(index).

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U5;

let bv = BitArray::<u32, U5>::from_fn(|i| { i % 2 == 0 });
assert!(bv.eq_vec(&[true, false, true, false, true]));

ⓘImportant traits for Blocks<'a, B>
Important traits for Blocks<'a, B>
`impl<'a, B: BitBlock> Iterator for Blocks<'a, B> type Item = B;`
`pub fn blocks(&self) -> Blocks`[src]

Iterator over the underlying blocks of data

`pub fn storage(&self) -> &[B]`[src]

Exposes the raw block storage of this BitArray

Only really intended for BitSet.

`pub unsafe fn storage_mut(&mut self) -> &mut [B]`[src]

Exposes the raw block storage of this BitArray

Can probably cause unsafety. Only really intended for BitSet.

`pub fn get(&self, i: usize) -> Option<bool>`[src]

Retrieves the value at index i, or None if the index is out of bounds.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b01100000]);
assert_eq!(bv.get(0), Some(false));
assert_eq!(bv.get(1), Some(true));
assert_eq!(bv.get(100), None);

// Can also use array indexing
assert_eq!(bv[1], true);

`pub fn set(&mut self, i: usize, x: bool)`[src]

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
bv.set(3, true);
assert_eq!(bv[3], true);

`pub fn set_all(&mut self)`[src]

Sets all bits to 1.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let before = 0b01100000;
let after  = 0b11111111;

let mut bv = BitArray::<u32, U8>::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, BitArray::<u32, U8>::from_bytes(&[after]));

`pub fn negate(&mut self)`[src]

Flips all bits.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let before = 0b01100000;
let after  = 0b10011111;

let mut bv = BitArray::<u32, U8>::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, BitArray::<u32, U8>::from_bytes(&[after]));

`pub fn union(&mut self, other: &Self) -> bool`[src]

Calculates the union of two bitarrays. This acts like the bitwise or function.

Sets self to the union of self and other. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different lengths.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01111110;

let mut a = BitArray::<u32, U8>::from_bytes(&[a]);
let b = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(a.union(&b));
assert_eq!(a, BitArray::<u32, U8>::from_bytes(&[res]));

`pub fn intersect(&mut self, other: &Self) -> bool`[src]

Calculates the intersection of two bitarrays. This acts like the bitwise and function.

Sets self to the intersection of self and other. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different lengths.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01000000;

let mut a = BitArray::<u32, U8>::from_bytes(&[a]);
let b = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(a.intersect(&b));
assert_eq!(a, BitArray::<u32, U8>::from_bytes(&[res]));

`pub fn difference(&mut self, other: &Self) -> bool`[src]

Calculates the difference between two bitarrays.

Sets each element of self to the value of that element minus the element of other at the same index. Both bitarrays must be the same length. Returns true if self changed.

Panics

Panics if the bitarrays are of different length.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let a_b = 0b00100100; // a - b
let b_a = 0b00011010; // b - a

let mut bva = BitArray::<u32, U8>::from_bytes(&[a]);
let bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bva.difference(&bvb));
assert_eq!(bva, BitArray::<u32, U8>::from_bytes(&[a_b]));

let bva = BitArray::<u32, U8>::from_bytes(&[a]);
let mut bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bvb.difference(&bva));
assert_eq!(bvb, BitArray::<u32, U8>::from_bytes(&[b_a]));

`pub fn symmetric_difference(&mut self, other: &Self) -> bool`[src]

Calculates the symmetric difference between two bitarrays.

Sets each element of self to 1 where the elements are different and 0 otherwise. Returns true if self changed.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let a   = 0b01100100;
let b   = 0b01011010;
let a_b = 0b00111110; // a ^ b
let b_a = 0b00111110; // b ^ a

let mut bva = BitArray::<u32, U8>::from_bytes(&[a]);
let bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bva.symmetric_difference(&bvb));
assert_eq!(bva, BitArray::<u32, U8>::from_bytes(&[a_b]));

let bva = BitArray::<u32, U8>::from_bytes(&[a]);
let mut bvb = BitArray::<u32, U8>::from_bytes(&[b]);

assert!(bvb.symmetric_difference(&bva));
assert_eq!(bvb, BitArray::<u32, U8>::from_bytes(&[b_a]));

`pub fn count_ones(&self) -> usize`[src]

Returns the number of bits set to 1.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(true);
assert_eq!(bv.count_ones(), 8);

bv.set(1, false);
assert_eq!(bv.count_ones(), 7);

`pub fn all(&self) -> bool`[src]

Returns true if all bits are 1.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(true);
assert_eq!(bv.all(), true);

bv.set(1, false);
assert_eq!(bv.all(), false);

ⓘImportant traits for Iter<'a, B, NBits>
Important traits for Iter<'a, B, NBits>
`impl<'a, B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Iterator for Iter<'a, B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength, type Item = bool;`
`pub fn iter(&self) -> Iter<B, NBits>`[src]

Returns an iterator over the elements of the array in order.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U16;

let bv = BitArray::<u32, U16>::from_bytes(&[0b01110100, 0b10010010]);
assert_eq!(bv.iter().filter(|x| *x).count(), 7);

`pub fn none(&self) -> bool`[src]

Returns true if all bits are 0.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
assert_eq!(bv.none(), true);

bv.set(3, true);
assert_eq!(bv.none(), false);

`pub fn any(&self) -> bool`[src]

Returns true if any bit is 1.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let mut bv = BitArray::<u32, U8>::from_elem(false);
assert_eq!(bv.any(), false);

bv.set(3, true);
assert_eq!(bv.any(), true);

`pub fn to_bytes(&self) -> Vec<u8>`[src]

Organises the bits into bytes, such that the first bit in the BitArray becomes the high-order bit of the first byte. If the size of the BitArray is not a multiple of eight then trailing bits will be filled-in with false.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::{U3, U9};

let mut bv = BitArray::<u32, U3>::from_elem(true);
bv.set(1, false);

assert_eq!(bv.to_bytes(), [0b10100000]);

let mut bv = BitArray::<u32, U9>::from_elem(false);
bv.set(2, true);
bv.set(8, true);

assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);

`pub fn eq_vec(&self, v: &[bool]) -> bool`[src]

Compares a BitArray to a slice of bools. Both the BitArray and slice must have the same length.

Panics

Panics if the BitArray and slice are of different length.

Examples

extern crate typenum;
use bitarray::BitArray;
use typenum::U8;

let bv = BitArray::<u32, U8>::from_bytes(&[0b10100000]);

assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false]));

`pub fn len() -> usize`[src]

Returns the total number of bits in this array

`pub fn block_len() -> usize`[src]

Returns the total number of blocks in this array

`pub fn is_empty() -> bool`[src]

Returns true if there are no bits.

`pub fn clear(&mut self)`[src]

Clears all bits in this array.

Trait Implementations

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialEq<BitArray<B, NBits>> for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn eq(&self, other: &Self) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`
1.0.0
[src]

This method tests for !=.

`impl<'a, B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> IntoIterator for &'a BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`type Item = bool`

The type of the elements being iterated over.

`type IntoIter = Iter<'a, B, NBits>`

Which kind of iterator are we turning this into?

ⓘImportant traits for Iter<'a, B, NBits>
Important traits for Iter<'a, B, NBits>
`impl<'a, B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Iterator for Iter<'a, B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength, type Item = bool;`
`fn into_iter(self) -> Iter<'a, B, NBits>`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> IntoIterator for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`type Item = bool`

The type of the elements being iterated over.

`type IntoIter = IntoIter<B, NBits>`

Which kind of iterator are we turning this into?

ⓘImportant traits for IntoIter<B, NBits>
Important traits for IntoIter<B, NBits>
`impl<B: BitBlock + BitsIn + Default, NBits: Unsigned + NonZero> Iterator for IntoIter<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength, type Item = bool;`
`fn into_iter(self) -> IntoIter<B, NBits>`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Default for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn default() -> Self`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Ord for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn cmp(&self, other: &Self) -> Ordering`[src]

`fn max(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the minimum of two values. Read more

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Clone for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn clone(&self) -> Self`[src]

`fn clone_from(&mut self, source: &Self)`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Eq for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialOrd<BitArray<B, NBits>> for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn partial_cmp(&self, other: &Self) -> Option<Ordering>`[src]

`#[must_use] fn lt(&self, other: &Rhs) -> bool`
1.0.0
[src]

This method tests less than (for self and other) and is used by the < operator. Read more

`#[must_use] fn le(&self, other: &Rhs) -> bool`
1.0.0
[src]

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

`#[must_use] fn gt(&self, other: &Rhs) -> bool`
1.0.0
[src]

This method tests greater than (for self and other) and is used by the > operator. Read more

`#[must_use] fn ge(&self, other: &Rhs) -> bool`
1.0.0
[src]

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Hash for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,`
1.3.0
[src]

Feeds a slice of this type into the given [Hasher]. Read more

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Index<usize> for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`type Output = bool`

The returned type after indexing.

`fn index(&self, i: usize) -> &bool`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> FromIterator<bool> for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self`[src]

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> Debug for BitArray<B, NBits> where NBits: Add<::Output>, <NBits as Add<::Output>>::Output: Sub<B1>, <<NBits as Add<::Output>>::Output as Sub<B1>>::Output: Div<::Output>, <<<NBits as Add<::Output>>::Output as Sub<B1>>::Output as Div<::Output>>::Output: ArrayLength,` [src]

`fn fmt(&self, fmt: &mut Formatter) -> Result`[src]

Auto Trait Implementations

`impl<B, NBits> Send for BitArray<B, NBits> where B: Send,`

`impl<B, NBits> Sync for BitArray<B, NBits> where B: Sync,`

Blanket Implementations

`impl IntoIterator for I where I: Iterator,` [src]

`type Item = ::Item`

The type of the elements being iterated over.

`type IntoIter = I`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> I`[src]

`impl<T> From for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = !`

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

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T> Borrow for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

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

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Same for T`[src]

`type Output = T`

Should always be Self

[−][src]Struct bitarray::BitArray

Methods

pub fn new() -> Self[src]

pub fn from_elem(bit: bool) -> Self[src]

pub fn from_bytes(bytes: &[u8]) -> Self[src]

pub fn from_fn<F>(f: F) -> Self where F: FnMut(usize) -> bool, [src]

ⓘImportant traits for Blocks<'a, B>Important traits for Blocks<'a, B>impl<'a, B: BitBlock> Iterator for Blocks<'a, B> type Item = B;pub fn blocks(&self) -> Blocks<B>[src]

Important traits for Blocks<'a, B>

pub fn storage(&self) -> &[B][src]

pub unsafe fn storage_mut(&mut self) -> &mut [B][src]

pub fn get(&self, i: usize) -> Option<bool>[src]

pub fn set(&mut self, i: usize, x: bool)[src]

pub fn set_all(&mut self)[src]

pub fn negate(&mut self)[src]

pub fn union(&mut self, other: &Self) -> bool[src]

pub fn intersect(&mut self, other: &Self) -> bool[src]

pub fn difference(&mut self, other: &Self) -> bool[src]

pub fn symmetric_difference(&mut self, other: &Self) -> bool[src]

pub fn count_ones(&self) -> usize[src]

pub fn all(&self) -> bool[src]

Important traits for Iter<'a, B, NBits>

pub fn none(&self) -> bool[src]

pub fn any(&self) -> bool[src]

pub fn to_bytes(&self) -> Vec<u8>[src]

pub fn eq_vec(&self, v: &[bool]) -> bool[src]

pub fn len() -> usize[src]

pub fn block_len() -> usize[src]

pub fn is_empty() -> bool[src]

pub fn clear(&mut self)[src]

Trait Implementations

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

#[must_use] fn ne(&self, other: &Rhs) -> bool1.0.0[src]

type Item = bool

type IntoIter = Iter<'a, B, NBits>

Important traits for Iter<'a, B, NBits>

type Item = bool

type IntoIter = IntoIter<B, NBits>

Important traits for IntoIter<B, NBits>

fn default() -> Self[src]

fn cmp(&self, other: &Self) -> Ordering[src]

fn max(self, other: Self) -> Self1.21.0[src]

fn min(self, other: Self) -> Self1.21.0[src]

fn clone(&self) -> Self[src]

fn clone_from(&mut self, source: &Self)[src]

fn partial_cmp(&self, other: &Self) -> Option<Ordering>[src]

#[must_use] fn lt(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use] fn le(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use] fn gt(&self, other: &Rhs) -> bool1.0.0[src]

#[must_use] fn ge(&self, other: &Rhs) -> bool1.0.0[src]

fn hash<H: Hasher>(&self, state: &mut H)[src]

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher, 1.3.0[src]

type Output = bool

fn index(&self, i: usize) -> &bool[src]

fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self[src]

fn fmt(&self, fmt: &mut Formatter) -> Result[src]

Auto Trait Implementations

impl<B, NBits> Send for BitArray<B, NBits> where B: Send,

impl<B, NBits> Sync for BitArray<B, NBits> where B: Sync,

Blanket Implementations

impl<I> IntoIterator for I where I: Iterator, [src]

type Item = <I as Iterator>::Item

type IntoIter = I

fn into_iter(self) -> I[src]

impl<T> From for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T> ToOwned for T where T: Clone, [src]

type Owned = T

fn to_owned(&self) -> T[src]

fn clone_into(&self, target: &mut T)[src]

impl<T, U> TryFrom for T where U: Into<T>, [src]

type Error = !

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T> Borrow for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T, U> TryInto for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

`pub fn new() -> Self`[src]

`pub fn from_elem(bit: bool) -> Self`[src]

`pub fn from_bytes(bytes: &[u8]) -> Self`[src]

`pub fn from_fn<F>(f: F) -> Self where F: FnMut(usize) -> bool,` [src]

ⓘImportant traits for Blocks<'a, B>
Important traits for Blocks<'a, B>
`impl<'a, B: BitBlock> Iterator for Blocks<'a, B> type Item = B;`
`pub fn blocks(&self) -> Blocks<B>`[src]

`pub fn storage(&self) -> &[B]`[src]

`pub unsafe fn storage_mut(&mut self) -> &mut [B]`[src]

`pub fn get(&self, i: usize) -> Option<bool>`[src]

`pub fn set(&mut self, i: usize, x: bool)`[src]

`pub fn set_all(&mut self)`[src]

`pub fn negate(&mut self)`[src]

`pub fn union(&mut self, other: &Self) -> bool`[src]

`pub fn intersect(&mut self, other: &Self) -> bool`[src]

`pub fn difference(&mut self, other: &Self) -> bool`[src]

`pub fn symmetric_difference(&mut self, other: &Self) -> bool`[src]

`pub fn count_ones(&self) -> usize`[src]

`pub fn all(&self) -> bool`[src]

`pub fn none(&self) -> bool`[src]

`pub fn any(&self) -> bool`[src]

`pub fn to_bytes(&self) -> Vec<u8>`[src]

`pub fn eq_vec(&self, v: &[bool]) -> bool`[src]

`pub fn len() -> usize`[src]

`pub fn block_len() -> usize`[src]

`pub fn is_empty() -> bool`[src]

`pub fn clear(&mut self)`[src]

`fn eq(&self, other: &Self) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`
1.0.0
[src]

`type Item = bool`

`type IntoIter = Iter<'a, B, NBits>`

`type Item = bool`

`type IntoIter = IntoIter<B, NBits>`

`fn default() -> Self`[src]

`fn cmp(&self, other: &Self) -> Ordering`[src]

`fn max(self, other: Self) -> Self`
1.21.0
[src]

`fn min(self, other: Self) -> Self`
1.21.0
[src]

`fn clone(&self) -> Self`[src]

`fn clone_from(&mut self, source: &Self)`[src]

`fn partial_cmp(&self, other: &Self) -> Option<Ordering>`[src]

`#[must_use] fn lt(&self, other: &Rhs) -> bool`
1.0.0
[src]

`#[must_use] fn le(&self, other: &Rhs) -> bool`
1.0.0
[src]

`#[must_use] fn gt(&self, other: &Rhs) -> bool`
1.0.0
[src]

`#[must_use] fn ge(&self, other: &Rhs) -> bool`
1.0.0
[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,`
1.3.0
[src]

`type Output = bool`

`fn index(&self, i: usize) -> &bool`[src]

`fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self`[src]

`fn fmt(&self, fmt: &mut Formatter) -> Result`[src]

`impl<B, NBits> Send for BitArray<B, NBits> where B: Send,`

`impl<B, NBits> Sync for BitArray<B, NBits> where B: Sync,`

`impl<I> IntoIterator for I where I: Iterator,` [src]

`type Item = <I as Iterator>::Item`

`type IntoIter = I`

`fn into_iter(self) -> I`[src]

`impl<T> From for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = !`

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T> Borrow for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Same for T`[src]

`type Output = T`