[−][src]Struct bdf::Bitmap
The bitmap of a glyph.
Implementations
impl Bitmap
[src]
pub fn new(width: u32, height: u32) -> Self
[src]
Creates a bitmap of the given size.
pub fn width(&self) -> u32
[src]
Gets the width.
pub fn height(&self) -> u32
[src]
Gets the height.
pub fn get(&self, x: u32, y: u32) -> bool
[src]
Gets a bit from the map.
pub fn set(&mut self, x: u32, y: u32, value: bool)
[src]
Sets a bit of the map.
Methods from Deref<Target = BitSet>
pub fn capacity(&self) -> usize
[src]
Returns the capacity in bits for this bit vector. Inserting any element less than this amount will not trigger a resizing.
Examples
use bit_set::BitSet; let mut s = BitSet::with_capacity(100); assert!(s.capacity() >= 100);
pub fn reserve_len(&mut self, len: usize)
[src]
Reserves capacity for the given BitSet
to contain len
distinct elements. In the case
of BitSet
this means reallocations will not occur as long as all inserted elements
are less than len
.
The collection may reserve more space to avoid frequent reallocations.
Examples
use bit_set::BitSet; let mut s = BitSet::new(); s.reserve_len(10); assert!(s.capacity() >= 10);
pub fn reserve_len_exact(&mut self, len: usize)
[src]
Reserves the minimum capacity for the given BitSet
to contain len
distinct elements.
In the case of BitSet
this means reallocations will not occur as long as all inserted
elements are less than len
.
Note that the allocator may give the collection more space than it requests. Therefore
capacity can not be relied upon to be precisely minimal. Prefer reserve_len
if future
insertions are expected.
Examples
use bit_set::BitSet; let mut s = BitSet::new(); s.reserve_len_exact(10); assert!(s.capacity() >= 10);
pub fn get_ref(&self) -> &BitVec<B>
[src]
Returns a reference to the underlying bit vector.
Examples
use bit_set::BitSet; let mut s = BitSet::new(); s.insert(0); let bv = s.get_ref(); assert_eq!(bv[0], true);
pub fn shrink_to_fit(&mut self)
[src]
Truncates the underlying vector to the least length required.
Examples
use bit_set::BitSet; let mut s = BitSet::new(); s.insert(32183231); s.remove(32183231); // Internal storage will probably be bigger than necessary println!("old capacity: {}", s.capacity()); // Now should be smaller s.shrink_to_fit(); println!("new capacity: {}", s.capacity());
pub fn iter(&self) -> Iter<B>
[src]
Iterator over each usize stored in the BitSet
.
Examples
use bit_set::BitSet; let s = BitSet::from_bytes(&[0b01001010]); // Print 1, 4, 6 in arbitrary order for x in s.iter() { println!("{}", x); }
pub fn union(&'a self, other: &'a BitSet<B>) -> Union<'a, B>
[src]
Iterator over each usize stored in self
union other
.
See union_with for an efficient in-place version.
Examples
use bit_set::BitSet; let a = BitSet::from_bytes(&[0b01101000]); let b = BitSet::from_bytes(&[0b10100000]); // Print 0, 1, 2, 4 in arbitrary order for x in a.union(&b) { println!("{}", x); }
pub fn intersection(&'a self, other: &'a BitSet<B>) -> Intersection<'a, B>
[src]
Iterator over each usize stored in self
intersect other
.
See intersect_with for an efficient in-place version.
Examples
use bit_set::BitSet; let a = BitSet::from_bytes(&[0b01101000]); let b = BitSet::from_bytes(&[0b10100000]); // Print 2 for x in a.intersection(&b) { println!("{}", x); }
pub fn difference(&'a self, other: &'a BitSet<B>) -> Difference<'a, B>
[src]
Iterator over each usize stored in the self
setminus other
.
See difference_with for an efficient in-place version.
Examples
use bit_set::BitSet; let a = BitSet::from_bytes(&[0b01101000]); let b = BitSet::from_bytes(&[0b10100000]); // Print 1, 4 in arbitrary order for x in a.difference(&b) { println!("{}", x); } // Note that difference is not symmetric, // and `b - a` means something else. // This prints 0 for x in b.difference(&a) { println!("{}", x); }
pub fn symmetric_difference(
&'a self,
other: &'a BitSet<B>
) -> SymmetricDifference<'a, B>
[src]
&'a self,
other: &'a BitSet<B>
) -> SymmetricDifference<'a, B>
Iterator over each usize stored in the symmetric difference of self
and other
.
See symmetric_difference_with for
an efficient in-place version.
Examples
use bit_set::BitSet; let a = BitSet::from_bytes(&[0b01101000]); let b = BitSet::from_bytes(&[0b10100000]); // Print 0, 1, 4 in arbitrary order for x in a.symmetric_difference(&b) { println!("{}", x); }
pub fn union_with(&mut self, other: &BitSet<B>)
[src]
Unions in-place with the specified other bit vector.
Examples
use bit_set::BitSet; let a = 0b01101000; let b = 0b10100000; let res = 0b11101000; let mut a = BitSet::from_bytes(&[a]); let b = BitSet::from_bytes(&[b]); let res = BitSet::from_bytes(&[res]); a.union_with(&b); assert_eq!(a, res);
pub fn intersect_with(&mut self, other: &BitSet<B>)
[src]
Intersects in-place with the specified other bit vector.
Examples
use bit_set::BitSet; let a = 0b01101000; let b = 0b10100000; let res = 0b00100000; let mut a = BitSet::from_bytes(&[a]); let b = BitSet::from_bytes(&[b]); let res = BitSet::from_bytes(&[res]); a.intersect_with(&b); assert_eq!(a, res);
pub fn difference_with(&mut self, other: &BitSet<B>)
[src]
Makes this bit vector the difference with the specified other bit vector in-place.
Examples
use bit_set::BitSet; let a = 0b01101000; let b = 0b10100000; let a_b = 0b01001000; // a - b let b_a = 0b10000000; // b - a let mut bva = BitSet::from_bytes(&[a]); let bvb = BitSet::from_bytes(&[b]); let bva_b = BitSet::from_bytes(&[a_b]); let bvb_a = BitSet::from_bytes(&[b_a]); bva.difference_with(&bvb); assert_eq!(bva, bva_b); let bva = BitSet::from_bytes(&[a]); let mut bvb = BitSet::from_bytes(&[b]); bvb.difference_with(&bva); assert_eq!(bvb, bvb_a);
pub fn symmetric_difference_with(&mut self, other: &BitSet<B>)
[src]
Makes this bit vector the symmetric difference with the specified other bit vector in-place.
Examples
use bit_set::BitSet; let a = 0b01101000; let b = 0b10100000; let res = 0b11001000; let mut a = BitSet::from_bytes(&[a]); let b = BitSet::from_bytes(&[b]); let res = BitSet::from_bytes(&[res]); a.symmetric_difference_with(&b); assert_eq!(a, res);
pub fn len(&self) -> usize
[src]
Returns the number of set bits in this set.
pub fn is_empty(&self) -> bool
[src]
Returns whether there are no bits set in this set
pub fn clear(&mut self)
[src]
Clears all bits in this set
pub fn contains(&self, value: usize) -> bool
[src]
Returns true
if this set contains the specified integer.
pub fn is_disjoint(&self, other: &BitSet<B>) -> bool
[src]
Returns true
if the set has no elements in common with other
.
This is equivalent to checking for an empty intersection.
pub fn is_subset(&self, other: &BitSet<B>) -> bool
[src]
Returns true
if the set is a subset of another.
pub fn is_superset(&self, other: &BitSet<B>) -> bool
[src]
Returns true
if the set is a superset of another.
pub fn insert(&mut self, value: usize) -> bool
[src]
Adds a value to the set. Returns true
if the value was not already
present in the set.
pub fn remove(&mut self, value: usize) -> bool
[src]
Removes a value from the set. Returns true
if the value was
present in the set.
Trait Implementations
impl Clone for Bitmap
[src]
impl Debug for Bitmap
[src]
impl Default for Bitmap
[src]
impl Deref for Bitmap
[src]
impl DerefMut for Bitmap
[src]
impl Eq for Bitmap
[src]
impl PartialEq<Bitmap> for Bitmap
[src]
impl StructuralEq for Bitmap
[src]
impl StructuralPartialEq for Bitmap
[src]
Auto Trait Implementations
impl RefUnwindSafe for Bitmap
impl Send for Bitmap
impl Sync for Bitmap
impl Unpin for Bitmap
impl UnwindSafe for Bitmap
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,