Struct Bitmap128

Source

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

Expand description

A bitmap of length 128.

§Examples

// Creates an empty bitmap
use fixed_bitmaps::Bitmap128;

let mut bitmap = Bitmap128::default();

// Bitmaps implement Display so you can view what the map looks like
println!("Default bitmap: {}", bitmap);

// Bitmaps also convert to their respective unsigned int versions and back again easily
// Will show 0 as the value of the bitmap
println!("Value of bitmap: {}", bitmap.to_u128());

// Let's do the same as above, but actually setting the values in the bitmap to something
bitmap |= Bitmap128::from(101);

println!("Bitmap after OR-ing with 101: {}", bitmap);

// Set the 4th index (the 5th bit) to true. Can simply unwrap the result to ignore the warning,
//as we know for certain that 4 < 128
bitmap.set(4, true).unwrap();

// Will show that 117 (101 + 2^4) is the value of the bitmap
println!("Bitmap value: {}", bitmap.to_u128());

// Or you could use the deref operator for an even easier conversion
println!("Bitmap value: {}", *bitmap);

Implementations§

Source §

Create a new bitmap that has its bits set from begin (inclusive) to end (exclusive). If begin is greater than the map length or end is 0, will return a bitmap with all bits set to the opposite of value.

§Example

use fixed_bitmaps::Bitmap128;

let a = Bitmap128::create_bit_mask(3, 7, true);
assert_eq!(*a, 0b1111000);

let b = Bitmap128::create_bit_mask(3, 6, false); // Results in 1..1000111
assert_eq!(b, Bitmap128::new(true) ^ 0b111000);

Examples found in repository ?

examples/using_bitmap8.rs (line 53)

3fn main() {
4    // Creates an empty bitmap
5    let mut bitmap = Bitmap8::default();
6
7    // Bitmaps implement Display so you can view what the map looks like
8    println!("Default bitmap: {}", bitmap);
9
10    // Bitmaps also convert to their respective unsigned int versions and back again easily
11    println!("Value of bitmap: {}", bitmap.to_u8());
12
13    // Let's do the same as above, but actually setting the values in the bitmap to something
14    bitmap |= Bitmap8::from(101);
15
16    // Will show 01100101
17    println!("Bitmap after OR-ing with 101: {}", bitmap);
18
19    // Set the 4th index (the 5th bit) to true. Can simply unwrap the result to remove the warning, as we know
20    // for certain that 4 < 63
21    bitmap.set(4, true).unwrap();
22
23    // Will show that 117 (101 + 2^4) is the value of the bitmap
24    println!("Bitmap value: {}", bitmap.to_u8());
25
26    // Will print out the error thrown when trying to set an index out of bounds
27    match bitmap.set(8, true) {
28        Ok(_) => println!("That wasn't meant to happen... something's up with my implementation!"),
29        Err(error) => {
30            println!("Yep, threw an error as expected. Error message is as follows:");
31            eprintln!("{}", error);
32        }
33    }
34
35    let a = Bitmap8::from_set(2).unwrap();
36
37    // The above is equivalent to:
38    let b = Bitmap8::from(0b100);
39
40    assert!(a == b);
41
42    let bitmap = Bitmap8::create_bit_mask(3, 6, true);
43    println!("{}", bitmap);
44    println!("{}", *bitmap);
45    println!("{}", 0b111000);
46
47    println!("{:b}", u8::MAX << 3);
48
49    let bitmap = Bitmap8::create_bit_mask(3, 6, false);
50    println!("{}", bitmap);
51    println!("{:b}", u8::MAX.wrapping_shl(8));
52
53    let a = Bitmap128::create_bit_mask(3, 6, false);
54    let b = Bitmap128::create_bit_mask(7, 8, false);
55    let c = Bitmap128::create_bit_mask(0, 1, false);
56    let d = Bitmap128::create_bit_mask(0, 0, false);
57    let e = Bitmap128::create_bit_mask(8, 8, false);
58    let f = Bitmap128::create_bit_mask(0, Bitmap128::MAP_LENGTH, false);
59
60    println!("{}", a);
61    println!("{}", b);
62    println!("{}", c);
63    println!("{}", d);
64    println!("{}", e);
65    println!("{}", f);
66}

Source

pub fn from_set(index: usize) -> Option<Bitmap128>

Creates a new, empty Bitmap128, and sets the desired index before returning.

use fixed_bitmaps::Bitmap128;

let a = Bitmap128::from_set(5).unwrap();

// The above is equivalent to:

let mut b = Bitmap128::from(0);
b.set(5, true);

assert_eq!(a, b);

Source

pub fn set(&mut self, index: usize, value: bool) -> Result<(), String>

Sets the desired index, to the value provided. Note that indexing starts at 0.

§Returns

Returns a Result based on the outcome. If an Err<String> was returned, it was because an out-of-bounds index was attempted to be set. In that case the bitmap’s state remains unchanged.

§Example

use fixed_bitmaps::Bitmap128;

let mut bitmap = Bitmap128::default();
assert_eq!(*bitmap, 0);

bitmap.set(4, true);
assert_eq!(*bitmap, 16);

Source

pub fn set_range(&mut self, begin: usize, end: usize, value: bool)

Set bits from begin (inclusive) to end (exclusive) to the given value.

§Example

use fixed_bitmaps::Bitmap128;

let mut bitmap = Bitmap128::default();
assert_eq!(*bitmap, 0);

bitmap.set_range(2, 7, true);
assert_eq!(*bitmap, 0b1111100);

bitmap.set_range(3, 5, false);
assert_eq!(*bitmap, 0b1100100);

Source

pub fn get(&self, index: usize) -> Result<bool, String>

Gets the bit at the given index. Note that indexing starts at 0.

§Returns

Returns a Result based on the outcome.

If Ok<bool> is returned, then the contained value in ok is the state of the given bit

If an Err<String> was returned, it was because you tried to get an out-of-bounds index.

§Example

use fixed_bitmaps::Bitmap128;

let bitmap = Bitmap128::from(0b1010);
assert_eq!(bitmap.get(2).unwrap(), false);
assert_eq!(bitmap.get(3).unwrap(), true);