Enum AsciiChar

#[repr(u8)]
pub enum AsciiChar {
    Null = 0,
    SOH = 1,
    SOX = 2,
    ETX = 3,
    EOT = 4,
    ENQ = 5,
    ACK = 6,
    Bell = 7,
    BackSpace = 8,
    Tab = 9,
    LineFeed = 10,
    VT = 11,
    FF = 12,
    CarriageReturn = 13,
    SI = 14,
    SO = 15,
    DLE = 16,
    DC1 = 17,
    DC2 = 18,
    DC3 = 19,
    DC4 = 20,
    NAK = 21,
    SYN = 22,
    ETB = 23,
    CAN = 24,
    EM = 25,
    SUB = 26,
    ESC = 27,
    FS = 28,
    GS = 29,
    RS = 30,
    US = 31,
    Space = 32,
    Exclamation = 33,
    Quotation = 34,
    Hash = 35,
    Dollar = 36,
    Percent = 37,
    Ampersand = 38,
    Apostrophe = 39,
    ParenOpen = 40,
    ParenClose = 41,
    Asterisk = 42,
    Plus = 43,
    Comma = 44,
    Minus = 45,
    Dot = 46,
    Slash = 47,
    _0 = 48,
    _1 = 49,
    _2 = 50,
    _3 = 51,
    _4 = 52,
    _5 = 53,
    _6 = 54,
    _7 = 55,
    _8 = 56,
    _9 = 57,
    Colon = 58,
    Semicolon = 59,
    LessThan = 60,
    Equal = 61,
    GreaterThan = 62,
    Question = 63,
    At = 64,
    A = 65,
    B = 66,
    C = 67,
    D = 68,
    E = 69,
    F = 70,
    G = 71,
    H = 72,
    I = 73,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    O = 79,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    U = 85,
    V = 86,
    W = 87,
    X = 88,
    Y = 89,
    Z = 90,
    BracketOpen = 91,
    BackSlash = 92,
    BracketClose = 93,
    Caret = 94,
    UnderScore = 95,
    Grave = 96,
    a = 97,
    b = 98,
    c = 99,
    d = 100,
    e = 101,
    f = 102,
    g = 103,
    h = 104,
    i = 105,
    j = 106,
    k = 107,
    l = 108,
    m = 109,
    n = 110,
    o = 111,
    p = 112,
    q = 113,
    r = 114,
    s = 115,
    t = 116,
    u = 117,
    v = 118,
    w = 119,
    x = 120,
    y = 121,
    z = 122,
    CurlyBraceOpen = 123,
    VerticalBar = 124,
    CurlyBraceClose = 125,
    Tilde = 126,
    DEL = 127,
}

An ASCII character. It wraps a u8, with the highest bit always zero.

Variants

Null = 0

'\0'

SOH = 1

Start Of Heading

SOX = 2

Start Of teXt

ETX = 3

End of TeXt

EOT = 4

End Of Transmission

ENQ = 5

Enquiry

ACK = 6

Acknowledgement

Bell = 7

bell / alarm / audible

'\a' is not recognized by Rust.

BackSpace = 8

Backspace

'\b' is not recognized by Rust.

Tab = 9

'\t'

LineFeed = 10

'\n'

VT = 11

Vertical tab

'\v' is not recognized by Rust.

FF = 12

Form Feed

'\f' is not recognized by Rust.

CarriageReturn = 13

'\r'

SI = 14

Shift In

SO = 15

Shift Out

DLE = 16

Data Link Escape

DC1 = 17

Device control 1, often XON

DC2 = 18

Device control 2

DC3 = 19

Device control 3, Often XOFF

DC4 = 20

Device control 4

NAK = 21

Negative AcKnowledgement

SYN = 22

Synchronous idle

ETB = 23

End of Transmission Block

CAN = 24

Cancel

EM = 25

End of Medium

SUB = 26

Substitute

ESC = 27

Escape

'\e' is not recognized by Rust.

FS = 28

File Separator

GS = 29

Group Separator

RS = 30

Record Separator

US = 31

Unit Separator

Space = 32

' '

Exclamation = 33

'!'

Quotation = 34

'"'

Hash = 35

'#'

Dollar = 36

'$'

Percent = 37

'%'

Ampersand = 38

'&'

Apostrophe = 39

'\''

ParenOpen = 40

'('

ParenClose = 41

')'

Asterisk = 42

'*'

Plus = 43

'+'

Comma = 44

','

Minus = 45

'-'

Dot = 46

'.'

Slash = 47

'/'

_0 = 48

'0'

_1 = 49

'1'

_2 = 50

'2'

_3 = 51

'3'

_4 = 52

'4'

_5 = 53

'5'

_6 = 54

'6'

_7 = 55

'7'

_8 = 56

'8'

_9 = 57

'9'

Colon = 58

':'

Semicolon = 59

';'

LessThan = 60

'<'

Equal = 61

'='

GreaterThan = 62

'>'

Question = 63

'?'

At = 64

'@'

A = 65

'A'

B = 66

'B'

C = 67

'C'

D = 68

'D'

E = 69

'E'

F = 70

'F'

G = 71

'G'

H = 72

'H'

I = 73

'I'

J = 74

'J'

K = 75

'K'

L = 76

'L'

M = 77

'M'

N = 78

'N'

O = 79

'O'

P = 80

'P'

Q = 81

'Q'

R = 82

'R'

S = 83

'S'

T = 84

'T'

U = 85

'U'

V = 86

'V'

W = 87

'W'

X = 88

'X'

Y = 89

'Y'

Z = 90

'Z'

BracketOpen = 91

'['

BackSlash = 92

'\'

BracketClose = 93

']'

Caret = 94

'_'

UnderScore = 95

'_'

Grave = 96

'’`

a = 97

'a'

b = 98

'b'

c = 99

'c'

d = 100

'd'

e = 101

'e'

f = 102

'f'

g = 103

'g'

h = 104

'h'

i = 105

'i'

j = 106

'j'

k = 107

'k'

l = 108

'l'

m = 109

'm'

n = 110

'n'

o = 111

'o'

p = 112

'p'

q = 113

'q'

r = 114

'r'

s = 115

's'

t = 116

't'

u = 117

'u'

v = 118

'v'

w = 119

'w'

x = 120

'x'

y = 121

'y'

z = 122

'z'

CurlyBraceOpen = 123

'{'

VerticalBar = 124

'|'

CurlyBraceClose = 125

'}'

Tilde = 126

'~'

DEL = 127

Delete

Implementations

impl AsciiChar

pub fn from<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError>

Constructs an ASCII character from a u8, char or other character type.

Failure

Returns Err(()) if the character can’t be ASCII encoded.

Example

let a = AsciiChar::from('g').unwrap();
assert_eq!(a.as_char(), 'g');

pub unsafe fn from_unchecked<C: ToAsciiChar>(ch: C) -> Self

Constructs an ASCII character from a char or u8 without any checks.

pub fn as_byte(self) -> u8

Converts an ASCII character into a u8.

pub fn as_char(self) -> char

Converts an ASCII character into a char.

pub fn is_alphabetic(self) -> bool

Check if the character is a letter (a-z, A-Z)

pub fn is_digit(self) -> bool

Check if the character is a number (0-9)

pub fn is_alphanumeric(self) -> bool

Check if the character is a letter or number

pub fn is_blank(self) -> bool

Check if the character is a space or horizontal tab

pub fn is_whitespace(self) -> bool

Check if the character is a ’ ’, ‘\t’, ‘\n’ or ‘\r’

pub fn is_control(self) -> bool

Check if the character is a control character

Examples

use ascii::ToAsciiChar;
assert_eq!('\0'.to_ascii_char().unwrap().is_control(), true);
assert_eq!('n'.to_ascii_char().unwrap().is_control(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_control(), false);
assert_eq!('\n'.to_ascii_char().unwrap().is_control(), true);

pub fn is_graph(self) -> bool

Checks if the character is printable (except space)

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_graph(), true);
assert_eq!(' '.to_ascii_char().unwrap().is_graph(), false);
assert_eq!('\n'.to_ascii_char().unwrap().is_graph(), false);

pub fn is_print(self) -> bool

Checks if the character is printable (including space)

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_print(), true);
assert_eq!(' '.to_ascii_char().unwrap().is_print(), true);
assert_eq!('\n'.to_ascii_char().unwrap().is_print(), false);

pub fn is_lowercase(self) -> bool

Checks if the character is alphabetic and lowercase

Examples

use ascii::ToAsciiChar;
assert_eq!('a'.to_ascii_char().unwrap().is_lowercase(), true);
assert_eq!('A'.to_ascii_char().unwrap().is_lowercase(), false);
assert_eq!('@'.to_ascii_char().unwrap().is_lowercase(), false);

pub fn is_uppercase(self) -> bool

Checks if the character is alphabetic and uppercase

Examples

use ascii::ToAsciiChar;
assert_eq!('A'.to_ascii_char().unwrap().is_uppercase(), true);
assert_eq!('a'.to_ascii_char().unwrap().is_uppercase(), false);
assert_eq!('@'.to_ascii_char().unwrap().is_uppercase(), false);

pub fn is_punctuation(self) -> bool

Checks if the character is punctuation

Examples

use ascii::ToAsciiChar;
assert_eq!('n'.to_ascii_char().unwrap().is_punctuation(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_punctuation(), false);
assert_eq!('_'.to_ascii_char().unwrap().is_punctuation(), true);
assert_eq!('~'.to_ascii_char().unwrap().is_punctuation(), true);

pub fn is_hex(self) -> bool

Checks if the character is a valid hex digit

Examples

use ascii::ToAsciiChar;
assert_eq!('5'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('a'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('F'.to_ascii_char().unwrap().is_hex(), true);
assert_eq!('G'.to_ascii_char().unwrap().is_hex(), false);
assert_eq!(' '.to_ascii_char().unwrap().is_hex(), false);

pub fn as_printable_char(self) -> char

Unicode has printable versions of the ASCII control codes, like ‘␛’.

This function is identical with .as_char() for all values .is_printable() returns true for, but replaces the control codes with those unicodes printable versions.

Examples

assert_eq!('\0'.to_ascii_char().unwrap().as_printable_char(), '␀');
assert_eq!('\n'.to_ascii_char().unwrap().as_printable_char(), '␊');
assert_eq!(' '.to_ascii_char().unwrap().as_printable_char(), ' ');
assert_eq!('p'.to_ascii_char().unwrap().as_printable_char(), 'p');

pub fn make_ascii_uppercase(&mut self)

Replaces letters a to z with A to Z

pub fn make_ascii_lowercase(&mut self)

Replaces letters A to Z with a to z

pub fn to_ascii_uppercase(&self) -> Self

Maps letters a…z to A…Z and returns everything else unchanged.

pub fn to_ascii_lowercase(&self) -> Self

Maps letters A…Z to a…z and returns everything else unchanged.

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

Compares two characters case-insensitively.

Trait Implementations

impl AsciiExt for AsciiChar

type Owned = AsciiChar

👎Deprecated since 1.26.0: use inherent methods instead

Container type for copied ASCII characters.

fn is_ascii(&self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead

Checks if the value is within the ASCII range.

fn to_ascii_uppercase(&self) -> AsciiChar

👎Deprecated since 1.26.0: use inherent methods instead

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

fn to_ascii_lowercase(&self) -> AsciiChar

👎Deprecated since 1.26.0: use inherent methods instead

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

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

👎Deprecated since 1.26.0: use inherent methods instead

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

fn make_ascii_uppercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead

Converts this type to its ASCII upper case equivalent in-place.

fn make_ascii_lowercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead

Converts this type to its ASCII lower case equivalent in-place.

impl Clone for AsciiChar

fn clone(&self) -> AsciiChar

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AsciiChar

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

Formats the value using the given formatter.

impl Default for AsciiChar

fn default() -> AsciiChar

Returns the “default value” for a type.

impl Display for AsciiChar

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

Formats the value using the given formatter.

impl<'a> Extend<&'a AsciiChar> for AsciiString

fn extend<I: IntoIterator<Item = &'a AsciiChar>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl Extend<AsciiChar> for AsciiString

fn extend<I: IntoIterator<Item = AsciiChar>>(&mut self, iterable: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl From<AsciiChar> for char

fn from(a: AsciiChar) -> char

Converts to this type from the input type.

impl From<AsciiChar> for u8

fn from(a: AsciiChar) -> u8

Converts to this type from the input type.

impl FromIterator<AsciiChar> for AsciiString

fn from_iter<I: IntoIterator<Item = AsciiChar>>(iter: I) -> AsciiString

Creates a value from an iterator.

impl Hash for AsciiChar

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AsciiChar

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<AsciiChar> for char

fn eq(&self, rhs: &AsciiChar) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<AsciiChar> for u8

fn eq(&self, rhs: &AsciiChar) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<char> for AsciiChar

fn eq(&self, rhs: &char) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<u8> for AsciiChar

fn eq(&self, rhs: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for AsciiChar

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<AsciiChar> for char

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<AsciiChar> for u8

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<char> for AsciiChar

fn partial_cmp(&self, rhs: &char) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u8> for AsciiChar

fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd for AsciiChar

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl ToAsciiChar for AsciiChar

fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError>

Convert to AsciiChar.

unsafe fn to_ascii_char_unchecked(self) -> AsciiChar

Convert to AsciiChar without checking that it is an ASCII character.

impl Copy for AsciiChar

impl Eq for AsciiChar

impl StructuralPartialEq for AsciiChar