Struct bit_array::BitArray [−] [src]

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 bit_array::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]

`fn new() -> Self`

Creates an empty BitArray.

Examples

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

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

`fn from_elem(bit: bool) -> Self`

Creates a BitArray, setting each element to bit.

Examples

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

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

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

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 bit_array::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]));

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

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

Examples

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

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

`fn blocks(&self) -> Blocks`

Iterator over the underlying blocks of data

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

Exposes the raw block storage of this BitArray

Only really intended for BitSet.

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

Exposes the raw block storage of this BitArray

Can probably cause unsafety. Only really intended for BitSet.

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

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

Examples

extern crate typenum;
use bit_array::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);

`fn set(&mut self, i: usize, x: bool)`

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

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

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

`fn set_all(&mut self)`

Sets all bits to 1.

Examples

extern crate typenum;
use bit_array::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]));

`fn negate(&mut self)`

Flips all bits.

Examples

extern crate typenum;
use bit_array::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]));

`fn union(&mut self, other: &Self) -> bool`

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 bit_array::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]));

`fn intersect(&mut self, other: &Self) -> bool`

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 bit_array::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]));

`fn difference(&mut self, other: &Self) -> bool`

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 bit_array::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]));

`fn all(&self) -> bool`

Returns true if all bits are 1.

Examples

extern crate typenum;
use bit_array::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);

`fn iter(&self) -> Iter<B, NBits>`

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

Examples

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

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

`fn none(&self) -> bool`

Returns true if all bits are 0.

Examples

extern crate typenum;
use bit_array::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);

`fn any(&self) -> bool`

Returns true if any bit is 1.

Examples

extern crate typenum;
use bit_array::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);

`fn to_bytes(&self) -> Vec<u8>`

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 bit_array::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]);

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

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 bit_array::BitArray;
use typenum::U8;

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

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

`fn len(&self) -> usize`

Returns the total number of bits in this array

`fn clear(&mut self)`

Clears all bits in this array.

Trait Implementations

`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`

The method for the indexing (container[index]) operation

`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`

Returns the "default value" for a type. Read more

`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`

Creates a value from an iterator. 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`

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialOrd 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>`

This method returns an ordering between self and other values if one exists. Read more

`fn lt(&self, other: &Rhs) -> bool`
1.0.0

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

`fn le(&self, other: &Rhs) -> bool`
1.0.0

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

`fn gt(&self, other: &Rhs) -> bool`
1.0.0

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

`fn ge(&self, other: &Rhs) -> bool`
1.0.0

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> 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`

This method returns an Ordering between self and other. Read more

`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`

Formats the value using the given formatter.

`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)`

Feeds this value into the given [Hasher]. Read more

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

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

`impl<B: BitsIn + BitBlock + Default, NBits: Unsigned + NonZero> PartialEq 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`

This method tests for self and other values to be equal, and is used by ==. Read more

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

This method tests for !=.

`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<'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?

`fn into_iter(self) -> Iter<'a, B, NBits>`

Creates an iterator from a value. Read more

`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?

`fn into_iter(self) -> IntoIter<B, NBits>`

Creates an iterator from a value. Read more

Struct bit_array::BitArray [−] [src]

Methods

fn new() -> Self

fn from_elem(bit: bool) -> Self

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

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

fn blocks(&self) -> Blocks<B>

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

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

fn get(&self, i: usize) -> Option<bool>

fn set(&mut self, i: usize, x: bool)

fn set_all(&mut self)

fn negate(&mut self)

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

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

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

fn all(&self) -> bool

fn iter(&self) -> Iter<B, NBits>

fn none(&self) -> bool

fn any(&self) -> bool

fn to_bytes(&self) -> Vec<u8>

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

fn len(&self) -> usize

fn clear(&mut self)

Trait Implementations

type Output = bool

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

fn default() -> Self

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

fn clone(&self) -> Self

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

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

fn lt(&self, other: &Rhs) -> bool1.0.0

fn le(&self, other: &Rhs) -> bool1.0.0

fn gt(&self, other: &Rhs) -> bool1.0.0

fn ge(&self, other: &Rhs) -> bool1.0.0

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

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

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

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

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

fn ne(&self, other: &Rhs) -> bool1.0.0

type Item = bool

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

fn into_iter(self) -> Iter<'a, B, NBits>

type Item = bool

type IntoIter = IntoIter<B, NBits>

fn into_iter(self) -> IntoIter<B, NBits>

`fn new() -> Self`

`fn from_elem(bit: bool) -> Self`

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

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

`fn blocks(&self) -> Blocks<B>`

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

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

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

`fn set(&mut self, i: usize, x: bool)`

`fn set_all(&mut self)`

`fn negate(&mut self)`

`fn union(&mut self, other: &Self) -> bool`

`fn intersect(&mut self, other: &Self) -> bool`

`fn difference(&mut self, other: &Self) -> bool`

`fn all(&self) -> bool`

`fn iter(&self) -> Iter<B, NBits>`

`fn none(&self) -> bool`

`fn any(&self) -> bool`

`fn to_bytes(&self) -> Vec<u8>`

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

`fn len(&self) -> usize`

`fn clear(&mut self)`

`type Output = bool`

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

`fn default() -> Self`

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

`fn clone(&self) -> Self`

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

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

`fn lt(&self, other: &Rhs) -> bool`
1.0.0

`fn le(&self, other: &Rhs) -> bool`
1.0.0

`fn gt(&self, other: &Rhs) -> bool`
1.0.0

`fn ge(&self, other: &Rhs) -> bool`
1.0.0

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

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

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

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

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

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

`type Item = bool`

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

`fn into_iter(self) -> Iter<'a, B, NBits>`

`type Item = bool`

`type IntoIter = IntoIter<B, NBits>`

`fn into_iter(self) -> IntoIter<B, NBits>`