Struct BitAlloc16

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

A bitmap consisting of only 16 bits. BitAlloc16 acts as the leaf (except the leaf bits of course) nodes in the segment trees.

Example

use bitmap_allocator::{BitAlloc, BitAlloc16};

let mut ba = BitAlloc16::default();
assert_eq!(BitAlloc16::CAP, 16);
ba.insert(0..16);
for i in 0..16 {
    assert!(ba.test(i));
}
ba.remove(2..8);
assert_eq!(ba.alloc(), Some(0));
assert_eq!(ba.alloc(), Some(1));
assert_eq!(ba.alloc(), Some(8));
ba.dealloc(0);
ba.dealloc(1);
ba.dealloc(8);

assert!(!ba.is_empty());

Trait Implementations

impl BitAlloc for BitAlloc16

const CAP: usize = 16usize

The bitmap has a total of CAP bits, numbered from 0 to CAP-1 inclusively.

const DEFAULT: Self

The default value. Workaround for const fn new() -> Self.

fn alloc(&mut self) -> Option<usize>

Allocate a free bit.

fn alloc_contiguous( &mut self, base: Option<usize>, size: usize, align_log2: usize, ) -> Option<usize>

Allocate a free block with a given size, and return the first bit position.

fn dealloc(&mut self, key: usize) -> bool

Free an allocated bit.

fn dealloc_contiguous(&mut self, base: usize, size: usize) -> bool

Free a contiguous block of bits.

fn insert(&mut self, range: Range<usize>)

Mark bits in the range as unallocated (available)

fn remove(&mut self, range: Range<usize>)

Reverse of insert

fn any(&self) -> bool

👎Deprecated: use !self.is_empty() instead

Whether there are free bits remaining

fn is_empty(&self) -> bool

Returns true if no bits is available.

fn test(&self, key: usize) -> bool

Whether a specific bit is free

fn next(&self, key: usize) -> Option<usize>

Find a index not less than a given key, where the bit is free.

impl Default for BitAlloc16

fn default() -> BitAlloc16

Returns the “default value” for a type.