fixed_bitmaps

Struct Bitmap8

Source 
pub struct Bitmap8(/* private fields */);
Expand description

A bitmap of length 8.

§Examples

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

let mut bitmap = Bitmap8::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_u8());

// Let's do the same as above, but actually setting the values in the bitmap to something
bitmap |= Bitmap8::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 < 8
bitmap.set(4, true).unwrap();

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

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

Implementations§

Source§

impl Bitmap8

Source

pub fn capacity() -> usize

Source

pub fn to_u8(&self) -> u8

Examples found in repository?
examples/using_bitmap8.rs (line 11)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
fn main() {
    // Creates an empty bitmap
    let mut bitmap = Bitmap8::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
    println!("Value of bitmap: {}", bitmap.to_u8());

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

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

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

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

    // Will print out the error thrown when trying to set an index out of bounds
    match bitmap.set(8, true) {
        Ok(_) => println!("That wasn't meant to happen... something's up with my implementation!"),
        Err(error) => {
            println!("Yep, threw an error as expected. Error message is as follows:");
            eprintln!("{}", error);
        }
    }

    let a = Bitmap8::from_set(2).unwrap();

    // The above is equivalent to:
    let b = Bitmap8::from(0b100);

    assert!(a == b);

    let bitmap = Bitmap8::create_bit_mask(3, 6, true);
    println!("{}", bitmap);
    println!("{}", *bitmap);
    println!("{}", 0b111000);

    println!("{:b}", u8::MAX << 3);

    let bitmap = Bitmap8::create_bit_mask(3, 6, false);
    println!("{}", bitmap);
    println!("{:b}", u8::MAX.wrapping_shl(8));

    let a = Bitmap128::create_bit_mask(3, 6, false);
    let b = Bitmap128::create_bit_mask(7, 8, false);
    let c = Bitmap128::create_bit_mask(0, 1, false);
    let d = Bitmap128::create_bit_mask(0, 0, false);
    let e = Bitmap128::create_bit_mask(8, 8, false);
    let f = Bitmap128::create_bit_mask(0, Bitmap128::MAP_LENGTH, false);

    println!("{}", a);
    println!("{}", b);
    println!("{}", c);
    println!("{}", d);
    println!("{}", e);
    println!("{}", f);
}
Source

pub fn new(value: bool) -> Bitmap8

Creates a new bitmap with all bits set to the given value.

§Example
use fixed_bitmaps::Bitmap8;

let a = Bitmap8::new(true);
assert_eq!(*a, u8::MAX);

let b = Bitmap8::new(false);
assert_eq!(*b, 0);
Source

pub fn create_bit_mask(begin: usize, end: usize, value: bool) -> Bitmap8

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::Bitmap8;

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

let b = Bitmap8::create_bit_mask(3, 6, false); // Results in 1..1000111
assert_eq!(b, Bitmap8::new(true) ^ 0b111000);
Examples found in repository?
examples/using_bitmap8.rs (line 42)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
fn main() {
    // Creates an empty bitmap
    let mut bitmap = Bitmap8::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
    println!("Value of bitmap: {}", bitmap.to_u8());

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

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

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

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

    // Will print out the error thrown when trying to set an index out of bounds
    match bitmap.set(8, true) {
        Ok(_) => println!("That wasn't meant to happen... something's up with my implementation!"),
        Err(error) => {
            println!("Yep, threw an error as expected. Error message is as follows:");
            eprintln!("{}", error);
        }
    }

    let a = Bitmap8::from_set(2).unwrap();

    // The above is equivalent to:
    let b = Bitmap8::from(0b100);

    assert!(a == b);

    let bitmap = Bitmap8::create_bit_mask(3, 6, true);
    println!("{}", bitmap);
    println!("{}", *bitmap);
    println!("{}", 0b111000);

    println!("{:b}", u8::MAX << 3);

    let bitmap = Bitmap8::create_bit_mask(3, 6, false);
    println!("{}", bitmap);
    println!("{:b}", u8::MAX.wrapping_shl(8));

    let a = Bitmap128::create_bit_mask(3, 6, false);
    let b = Bitmap128::create_bit_mask(7, 8, false);
    let c = Bitmap128::create_bit_mask(0, 1, false);
    let d = Bitmap128::create_bit_mask(0, 0, false);
    let e = Bitmap128::create_bit_mask(8, 8, false);
    let f = Bitmap128::create_bit_mask(0, Bitmap128::MAP_LENGTH, false);

    println!("{}", a);
    println!("{}", b);
    println!("{}", c);
    println!("{}", d);
    println!("{}", e);
    println!("{}", f);
}
Source

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

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

use fixed_bitmaps::Bitmap8;

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

// The above is equivalent to:

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

assert_eq!(a, b);
Examples found in repository?
examples/using_bitmap8.rs (line 35)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
fn main() {
    // Creates an empty bitmap
    let mut bitmap = Bitmap8::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
    println!("Value of bitmap: {}", bitmap.to_u8());

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

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

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

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

    // Will print out the error thrown when trying to set an index out of bounds
    match bitmap.set(8, true) {
        Ok(_) => println!("That wasn't meant to happen... something's up with my implementation!"),
        Err(error) => {
            println!("Yep, threw an error as expected. Error message is as follows:");
            eprintln!("{}", error);
        }
    }

    let a = Bitmap8::from_set(2).unwrap();

    // The above is equivalent to:
    let b = Bitmap8::from(0b100);

    assert!(a == b);

    let bitmap = Bitmap8::create_bit_mask(3, 6, true);
    println!("{}", bitmap);
    println!("{}", *bitmap);
    println!("{}", 0b111000);

    println!("{:b}", u8::MAX << 3);

    let bitmap = Bitmap8::create_bit_mask(3, 6, false);
    println!("{}", bitmap);
    println!("{:b}", u8::MAX.wrapping_shl(8));

    let a = Bitmap128::create_bit_mask(3, 6, false);
    let b = Bitmap128::create_bit_mask(7, 8, false);
    let c = Bitmap128::create_bit_mask(0, 1, false);
    let d = Bitmap128::create_bit_mask(0, 0, false);
    let e = Bitmap128::create_bit_mask(8, 8, false);
    let f = Bitmap128::create_bit_mask(0, Bitmap128::MAP_LENGTH, false);

    println!("{}", a);
    println!("{}", b);
    println!("{}", c);
    println!("{}", d);
    println!("{}", e);
    println!("{}", f);
}
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::Bitmap8;

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

bitmap.set(4, true);
assert_eq!(*bitmap, 16);
Examples found in repository?
examples/using_bitmap8.rs (line 21)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
fn main() {
    // Creates an empty bitmap
    let mut bitmap = Bitmap8::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
    println!("Value of bitmap: {}", bitmap.to_u8());

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

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

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

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

    // Will print out the error thrown when trying to set an index out of bounds
    match bitmap.set(8, true) {
        Ok(_) => println!("That wasn't meant to happen... something's up with my implementation!"),
        Err(error) => {
            println!("Yep, threw an error as expected. Error message is as follows:");
            eprintln!("{}", error);
        }
    }

    let a = Bitmap8::from_set(2).unwrap();

    // The above is equivalent to:
    let b = Bitmap8::from(0b100);

    assert!(a == b);

    let bitmap = Bitmap8::create_bit_mask(3, 6, true);
    println!("{}", bitmap);
    println!("{}", *bitmap);
    println!("{}", 0b111000);

    println!("{:b}", u8::MAX << 3);

    let bitmap = Bitmap8::create_bit_mask(3, 6, false);
    println!("{}", bitmap);
    println!("{:b}", u8::MAX.wrapping_shl(8));

    let a = Bitmap128::create_bit_mask(3, 6, false);
    let b = Bitmap128::create_bit_mask(7, 8, false);
    let c = Bitmap128::create_bit_mask(0, 1, false);
    let d = Bitmap128::create_bit_mask(0, 0, false);
    let e = Bitmap128::create_bit_mask(8, 8, false);
    let f = Bitmap128::create_bit_mask(0, Bitmap128::MAP_LENGTH, false);

    println!("{}", a);
    println!("{}", b);
    println!("{}", c);
    println!("{}", d);
    println!("{}", e);
    println!("{}", f);
}
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::Bitmap8;

let mut bitmap = Bitmap8::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::Bitmap8;

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

Methods from Deref<Target = u8>§

1.43.0 · Source

pub const MIN: u8 = 0u8

1.43.0 · Source

pub const MAX: u8 = 255u8

1.53.0 · Source

pub const BITS: u32 = 8u32

1.23.0 · Source

pub fn is_ascii(&self) -> bool

Checks if the value is within the ASCII range.

§Examples
let ascii = 97u8;
let non_ascii = 150u8;

assert!(ascii.is_ascii());
assert!(!non_ascii.is_ascii());
Source

pub fn as_ascii(&self) -> Option<AsciiChar>

🔬This is a nightly-only experimental API. (ascii_char)

If the value of this byte is within the ASCII range, returns it as an ASCII character. Otherwise, returns None.

1.23.0 · Source

pub fn to_ascii_uppercase(&self) -> u8

Makes a copy of the value in its ASCII upper case equivalent.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

To uppercase the value in-place, use make_ascii_uppercase.

§Examples
let lowercase_a = 97u8;

assert_eq!(65, lowercase_a.to_ascii_uppercase());
1.23.0 · Source

pub fn to_ascii_lowercase(&self) -> u8

Makes a copy of the value in its ASCII lower case equivalent.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

To lowercase the value in-place, use make_ascii_lowercase.

§Examples
let uppercase_a = 65u8;

assert_eq!(97, uppercase_a.to_ascii_lowercase());
1.23.0 · Source

pub fn eq_ignore_ascii_case(&self, other: &u8) -> bool

Checks that two values are an ASCII case-insensitive match.

This is equivalent to to_ascii_lowercase(a) == to_ascii_lowercase(b).

§Examples
let lowercase_a = 97u8;
let uppercase_a = 65u8;

assert!(lowercase_a.eq_ignore_ascii_case(&uppercase_a));
1.24.0 · Source

pub fn is_ascii_alphabetic(&self) -> bool

Checks if the value is an ASCII alphabetic character:

  • U+0041 ‘A’ ..= U+005A ‘Z’, or
  • U+0061 ‘a’ ..= U+007A ‘z’.
§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(uppercase_a.is_ascii_alphabetic());
assert!(uppercase_g.is_ascii_alphabetic());
assert!(a.is_ascii_alphabetic());
assert!(g.is_ascii_alphabetic());
assert!(!zero.is_ascii_alphabetic());
assert!(!percent.is_ascii_alphabetic());
assert!(!space.is_ascii_alphabetic());
assert!(!lf.is_ascii_alphabetic());
assert!(!esc.is_ascii_alphabetic());
1.24.0 · Source

pub fn is_ascii_uppercase(&self) -> bool

Checks if the value is an ASCII uppercase character: U+0041 ‘A’ ..= U+005A ‘Z’.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(uppercase_a.is_ascii_uppercase());
assert!(uppercase_g.is_ascii_uppercase());
assert!(!a.is_ascii_uppercase());
assert!(!g.is_ascii_uppercase());
assert!(!zero.is_ascii_uppercase());
assert!(!percent.is_ascii_uppercase());
assert!(!space.is_ascii_uppercase());
assert!(!lf.is_ascii_uppercase());
assert!(!esc.is_ascii_uppercase());
1.24.0 · Source

pub fn is_ascii_lowercase(&self) -> bool

Checks if the value is an ASCII lowercase character: U+0061 ‘a’ ..= U+007A ‘z’.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(!uppercase_a.is_ascii_lowercase());
assert!(!uppercase_g.is_ascii_lowercase());
assert!(a.is_ascii_lowercase());
assert!(g.is_ascii_lowercase());
assert!(!zero.is_ascii_lowercase());
assert!(!percent.is_ascii_lowercase());
assert!(!space.is_ascii_lowercase());
assert!(!lf.is_ascii_lowercase());
assert!(!esc.is_ascii_lowercase());
1.24.0 · Source

pub fn is_ascii_alphanumeric(&self) -> bool

Checks if the value is an ASCII alphanumeric character:

  • U+0041 ‘A’ ..= U+005A ‘Z’, or
  • U+0061 ‘a’ ..= U+007A ‘z’, or
  • U+0030 ‘0’ ..= U+0039 ‘9’.
§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(uppercase_a.is_ascii_alphanumeric());
assert!(uppercase_g.is_ascii_alphanumeric());
assert!(a.is_ascii_alphanumeric());
assert!(g.is_ascii_alphanumeric());
assert!(zero.is_ascii_alphanumeric());
assert!(!percent.is_ascii_alphanumeric());
assert!(!space.is_ascii_alphanumeric());
assert!(!lf.is_ascii_alphanumeric());
assert!(!esc.is_ascii_alphanumeric());
1.24.0 · Source

pub fn is_ascii_digit(&self) -> bool

Checks if the value is an ASCII decimal digit: U+0030 ‘0’ ..= U+0039 ‘9’.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(!uppercase_a.is_ascii_digit());
assert!(!uppercase_g.is_ascii_digit());
assert!(!a.is_ascii_digit());
assert!(!g.is_ascii_digit());
assert!(zero.is_ascii_digit());
assert!(!percent.is_ascii_digit());
assert!(!space.is_ascii_digit());
assert!(!lf.is_ascii_digit());
assert!(!esc.is_ascii_digit());
Source

pub fn is_ascii_octdigit(&self) -> bool

🔬This is a nightly-only experimental API. (is_ascii_octdigit)

Checks if the value is an ASCII octal digit: U+0030 ‘0’ ..= U+0037 ‘7’.

§Examples
#![feature(is_ascii_octdigit)]

let uppercase_a = b'A';
let a = b'a';
let zero = b'0';
let seven = b'7';
let nine = b'9';
let percent = b'%';
let lf = b'\n';

assert!(!uppercase_a.is_ascii_octdigit());
assert!(!a.is_ascii_octdigit());
assert!(zero.is_ascii_octdigit());
assert!(seven.is_ascii_octdigit());
assert!(!nine.is_ascii_octdigit());
assert!(!percent.is_ascii_octdigit());
assert!(!lf.is_ascii_octdigit());
1.24.0 · Source

pub fn is_ascii_hexdigit(&self) -> bool

Checks if the value is an ASCII hexadecimal digit:

  • U+0030 ‘0’ ..= U+0039 ‘9’, or
  • U+0041 ‘A’ ..= U+0046 ‘F’, or
  • U+0061 ‘a’ ..= U+0066 ‘f’.
§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(uppercase_a.is_ascii_hexdigit());
assert!(!uppercase_g.is_ascii_hexdigit());
assert!(a.is_ascii_hexdigit());
assert!(!g.is_ascii_hexdigit());
assert!(zero.is_ascii_hexdigit());
assert!(!percent.is_ascii_hexdigit());
assert!(!space.is_ascii_hexdigit());
assert!(!lf.is_ascii_hexdigit());
assert!(!esc.is_ascii_hexdigit());
1.24.0 · Source

pub fn is_ascii_punctuation(&self) -> bool

Checks if the value is an ASCII punctuation character:

  • U+0021 ..= U+002F ! " # $ % & ' ( ) * + , - . /, or
  • U+003A ..= U+0040 : ; < = > ? @, or
  • U+005B ..= U+0060 [ \ ] ^ _ `, or
  • U+007B ..= U+007E { | } ~
§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(!uppercase_a.is_ascii_punctuation());
assert!(!uppercase_g.is_ascii_punctuation());
assert!(!a.is_ascii_punctuation());
assert!(!g.is_ascii_punctuation());
assert!(!zero.is_ascii_punctuation());
assert!(percent.is_ascii_punctuation());
assert!(!space.is_ascii_punctuation());
assert!(!lf.is_ascii_punctuation());
assert!(!esc.is_ascii_punctuation());
1.24.0 · Source

pub fn is_ascii_graphic(&self) -> bool

Checks if the value is an ASCII graphic character: U+0021 ‘!’ ..= U+007E ‘~’.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(uppercase_a.is_ascii_graphic());
assert!(uppercase_g.is_ascii_graphic());
assert!(a.is_ascii_graphic());
assert!(g.is_ascii_graphic());
assert!(zero.is_ascii_graphic());
assert!(percent.is_ascii_graphic());
assert!(!space.is_ascii_graphic());
assert!(!lf.is_ascii_graphic());
assert!(!esc.is_ascii_graphic());
1.24.0 · Source

pub fn is_ascii_whitespace(&self) -> bool

Checks if the value is an ASCII whitespace character: U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED, U+000C FORM FEED, or U+000D CARRIAGE RETURN.

Rust uses the WhatWG Infra Standard’s definition of ASCII whitespace. There are several other definitions in wide use. For instance, the POSIX locale includes U+000B VERTICAL TAB as well as all the above characters, but—from the very same specification—the default rule for “field splitting” in the Bourne shell considers only SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.

If you are writing a program that will process an existing file format, check what that format’s definition of whitespace is before using this function.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(!uppercase_a.is_ascii_whitespace());
assert!(!uppercase_g.is_ascii_whitespace());
assert!(!a.is_ascii_whitespace());
assert!(!g.is_ascii_whitespace());
assert!(!zero.is_ascii_whitespace());
assert!(!percent.is_ascii_whitespace());
assert!(space.is_ascii_whitespace());
assert!(lf.is_ascii_whitespace());
assert!(!esc.is_ascii_whitespace());
1.24.0 · Source

pub fn is_ascii_control(&self) -> bool

Checks if the value is an ASCII control character: U+0000 NUL ..= U+001F UNIT SEPARATOR, or U+007F DELETE. Note that most ASCII whitespace characters are control characters, but SPACE is not.

§Examples
let uppercase_a = b'A';
let uppercase_g = b'G';
let a = b'a';
let g = b'g';
let zero = b'0';
let percent = b'%';
let space = b' ';
let lf = b'\n';
let esc = b'\x1b';

assert!(!uppercase_a.is_ascii_control());
assert!(!uppercase_g.is_ascii_control());
assert!(!a.is_ascii_control());
assert!(!g.is_ascii_control());
assert!(!zero.is_ascii_control());
assert!(!percent.is_ascii_control());
assert!(!space.is_ascii_control());
assert!(lf.is_ascii_control());
assert!(esc.is_ascii_control());

Trait Implementations§

Source§

impl Add<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the + operator.
Source§

fn add(self, rhs: u8) -> Self::Output

Performs the + operation. Read more
Source§

impl Add for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the + operator.
Source§

fn add(self, rhs: Self) -> Self::Output

Performs the + operation. Read more
Source§

impl AddAssign<u8> for Bitmap8

Source§

fn add_assign(&mut self, rhs: u8)

Performs the += operation. Read more
Source§

impl AddAssign for Bitmap8

Source§

fn add_assign(&mut self, rhs: Self)

Performs the += operation. Read more
Source§

impl BitAnd<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the & operator.
Source§

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation. Read more
Source§

impl BitAnd for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the & operator.
Source§

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation. Read more
Source§

impl BitAndAssign<u8> for Bitmap8

Source§

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation. Read more
Source§

impl BitAndAssign for Bitmap8

Source§

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation. Read more
Source§

impl BitOr<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the | operator.
Source§

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation. Read more
Source§

impl BitOr for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the | operator.
Source§

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation. Read more
Source§

impl BitOrAssign<u8> for Bitmap8

Source§

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation. Read more
Source§

impl BitOrAssign for Bitmap8

Source§

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation. Read more
Source§

impl BitXor<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the ^ operator.
Source§

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation. Read more
Source§

impl BitXor for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the ^ operator.
Source§

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation. Read more
Source§

impl BitXorAssign<u8> for Bitmap8

Source§

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation. Read more
Source§

impl BitXorAssign for Bitmap8

Source§

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation. Read more
Source§

impl BitmapSize for Bitmap8

Source§

const MAP_LENGTH: usize = 8usize

Source§

impl Clone for Bitmap8

Source§

fn clone(&self) -> Bitmap8

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Bitmap8

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for Bitmap8

Source§

fn default() -> Bitmap8

Returns the “default value” for a type. Read more
Source§

impl Deref for Bitmap8

Source§

type Target = u8

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<'de> Deserialize<'de> for Bitmap8

Source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl Display for Bitmap8

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Div<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the / operator.
Source§

fn div(self, rhs: u8) -> Self::Output

Performs the / operation. Read more
Source§

impl Div for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the / operator.
Source§

fn div(self, rhs: Self) -> Self::Output

Performs the / operation. Read more
Source§

impl DivAssign<u8> for Bitmap8

Source§

fn div_assign(&mut self, rhs: u8)

Performs the /= operation. Read more
Source§

impl DivAssign for Bitmap8

Source§

fn div_assign(&mut self, rhs: Self)

Performs the /= operation. Read more
Source§

impl From<u8> for Bitmap8

Source§

fn from(value: u8) -> Self

Converts to this type from the input type.
Source§

impl Hash for Bitmap8

Source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

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

Feeds a slice of this type into the given Hasher. Read more
Source§

impl Mul<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation. Read more
Source§

impl Mul for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the * operator.
Source§

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation. Read more
Source§

impl MulAssign<u8> for Bitmap8

Source§

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation. Read more
Source§

impl MulAssign for Bitmap8

Source§

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation. Read more
Source§

impl Not for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the ! operator.
Source§

fn not(self) -> Self::Output

Performs the unary ! operation. Read more
Source§

impl Ord for Bitmap8

Source§

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

This method returns an Ordering between self and other. Read more
1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

impl PartialEq for Bitmap8

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialOrd for Bitmap8

Source§

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

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

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

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl Serialize for Bitmap8

Source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
Source§

impl Shl<usize> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the << operator.
Source§

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation. Read more
Source§

impl ShlAssign<usize> for Bitmap8

Source§

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation. Read more
Source§

impl Shr<usize> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the >> operator.
Source§

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation. Read more
Source§

impl ShrAssign<usize> for Bitmap8

Source§

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation. Read more
Source§

impl Sub<u8> for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub for Bitmap8

Source§

type Output = Bitmap8

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation. Read more
Source§

impl SubAssign<u8> for Bitmap8

Source§

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation. Read more
Source§

impl SubAssign for Bitmap8

Source§

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation. Read more
Source§

impl Copy for Bitmap8

Source§

impl Eq for Bitmap8

Source§

impl StructuralPartialEq for Bitmap8

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,