Struct Glyph 

pub struct Glyph { /* private fields */ }

A font glyph.

Implementations

impl Glyph

pub fn new<T: Into<String>>(name: T, codepoint: char) -> Self

Creates a new glyph with the given name and codepoint.

pub fn validate(&self) -> bool

Validates the definition.

pub fn name(&self) -> &str

Gets the name.

pub fn set_name<T: Into<String>>(&mut self, name: T)

Sets the name.

pub fn codepoint(&self) -> char

Gets the codepoint.

pub fn set_codepoint(&mut self, codepoint: char)

Sets the codepoint.

pub fn direction(&self) -> Direction

Gets the direction.

pub fn set_direction(&mut self, direction: Direction)

Sets the direction.

pub fn scalable_width(&self) -> Option<&(u32, u32)>

Gets the scalable width.

pub fn set_scalable_width(&mut self, value: Option<(u32, u32)>)

Sets the scalable width.

pub fn device_width(&self) -> Option<&(u32, u32)>

Gets the device width.

pub fn set_device_width(&mut self, value: Option<(u32, u32)>)

Sets the device width.

pub fn alternate_scalable_width(&self) -> Option<&(u32, u32)>

Gets the alternate scalable width.

pub fn set_alternate_scalable_width(&mut self, value: Option<(u32, u32)>)

Sets the alternate scalable width.

pub fn alternate_device_width(&self) -> Option<&(u32, u32)>

Gets the alternate device width.

pub fn set_alternate_device_width(&mut self, value: Option<(u32, u32)>)

Sets the alternate device width.

pub fn vector(&self) -> Option<&(u32, u32)>

Gets the offset vector.

pub fn set_vector(&mut self, value: Option<(u32, u32)>)

Sets the offset vector.

pub fn bounds(&self) -> &BoundingBox

Gets the bounds.

pub fn set_bounds(&mut self, bounds: BoundingBox)

Sets the bounds.

pub fn map(&self) -> &Bitmap

Gets the bitmap.

pub fn set_map(&mut self, map: Bitmap)

Sets the bitmap.

pub fn pixels(&self) -> PixelIter<'_>

Create an iterator over the pixels which will yield ((x, y), value).

Methods from Deref<Target = Bitmap>

pub fn width(&self) -> u32

Gets the width.

pub fn height(&self) -> u32

Gets the height.

pub fn get(&self, x: u32, y: u32) -> bool

Gets a bit from the map.

pub fn set(&mut self, x: u32, y: u32, value: bool)

Sets a bit of the map.

Methods from Deref<Target = BitSet>

pub fn capacity(&self) -> usize

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)

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)

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>

Returns a reference to the underlying bit vector.

Examples

use bit_set::BitSet;

let mut set = BitSet::new();
set.insert(0);

let bv = set.get_ref();
assert_eq!(bv[0], true);

pub fn get_mut(&mut self) -> &mut BitVec<B>

Returns a mutable reference to the underlying bit vector.

Examples

use bit_set::BitSet;

let mut set = BitSet::new();
set.insert(0);
set.insert(3);

{
    let bv = set.get_mut();
    bv.set(1, true);
}

assert!(set.contains(0));
assert!(set.contains(1));
assert!(set.contains(3));

pub fn shrink_to_fit(&mut self)

Truncates the underlying vector to the least length required.

Examples

use bit_set::BitSet;

let mut s = BitSet::new();
s.insert(3231);
s.remove(3231);

// Internal storage will probably be bigger than necessary
println!("old capacity: {}", s.capacity());
assert!(s.capacity() >= 3231);

// Now should be smaller
s.shrink_to_fit();
println!("new capacity: {}", s.capacity());

pub fn iter(&self) -> Iter<'_, B>

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>(&'a self, other: &'a BitSet<B>) -> Union<'a, B>

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>(&'a self, other: &'a BitSet<B>) -> Intersection<'a, B>

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>(&'a self, other: &'a BitSet<B>) -> Difference<'a, B>

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>( &'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>)

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

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

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

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

Returns the number of set bits in this set.

pub fn is_empty(&self) -> bool

Returns whether there are no bits set in this set

pub fn clear(&mut self)

Clears all bits in this set

pub fn contains(&self, value: usize) -> bool

Returns true if this set contains the specified integer.

pub fn is_disjoint(&self, other: &BitSet<B>) -> bool

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

Returns true if the set is a subset of another.

pub fn is_superset(&self, other: &BitSet<B>) -> bool

Returns true if the set is a superset of another.

pub fn insert(&mut self, value: usize) -> bool

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

Removes a value from the set. Returns true if the value was present in the set.

pub fn truncate(&mut self, element: usize)

Excludes element and all greater elements from the BitSet.

Trait Implementations

impl Clone for Glyph

fn clone(&self) -> Glyph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Glyph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Glyph

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Glyph

type Target = Bitmap

The resulting type after dereferencing.

fn deref(&self) -> &Bitmap

Dereferences the value.

impl DerefMut for Glyph

fn deref_mut(&mut self) -> &mut Bitmap

Mutably dereferences the value.