Enum ascii::AsciiChar[−][src]

[−]

[+] Expand attributes
#[repr(u8)]pub enum AsciiChar {
    Null,
    SOH,
    SOX,
    ETX,
    EOT,
    ENQ,
    ACK,
    Bell,
    BackSpace,
    Tab,
    LineFeed,
    VT,
    FF,
    CarriageReturn,
    SI,
    SO,
    DLE,
    DC1,
    DC2,
    DC3,
    DC4,
    NAK,
    SYN,
    ETB,
    CAN,
    EM,
    SUB,
    ESC,
    FS,
    GS,
    RS,
    US,
    Space,
    Exclamation,
    Quotation,
    Hash,
    Dollar,
    Percent,
    Ampersand,
    Apostrophe,
    ParenOpen,
    ParenClose,
    Asterisk,
    Plus,
    Comma,
    Minus,
    Dot,
    Slash,
    _0,
    _1,
    _2,
    _3,
    _4,
    _5,
    _6,
    _7,
    _8,
    _9,
    Colon,
    Semicolon,
    LessThan,
    Equal,
    GreaterThan,
    Question,
    At,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z,
    BracketOpen,
    BackSlash,
    BracketClose,
    Caret,
    UnderScore,
    Grave,
    a,
    b,
    c,
    d,
    e,
    f,
    g,
    h,
    i,
    j,
    k,
    l,
    m,
    n,
    o,
    p,
    q,
    r,
    s,
    t,
    u,
    v,
    w,
    x,
    y,
    z,
    CurlyBraceOpen,
    VerticalBar,
    CurlyBraceClose,
    Tilde,
    DEL,
}

[−]

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

Variants

Null

[−]

'\0'

SOH

SOX

ETX

EOT

ENQ

ACK

Bell

bell / alarm / audible

'\a' is not recognized by Rust.

BackSpace

[−]

Backspace

'\b' is not recognized by Rust.

Tab

[−]

'\t'

LineFeed

[−]

'\n'

VT

[−]

Vertical tab

'\v' is not recognized by Rust.

FF

[−]

Form Feed

'\f' is not recognized by Rust.

CarriageReturn

[−]

'\r'

SI

SO

DLE

DC1

Device control 1, often XON

DC2

[−]

Device control 2

DC3

[−]

Device control 3, Often XOFF

DC4

[−]

Device control 4

NAK

[−]

Negative AcKnowledgement

SYN

[−]

Synchronous idle

ETB

[−]

End of Transmission Block

CAN

EM

SUB

ESC

'\e' is not recognized by Rust.

FS

GS

RS

US

Space

' '

Exclamation

[−]

'!'

Quotation

[−]

'"'

Hash

[−]

'#'

Dollar

[−]

'$'

Percent

[−]

'%'

Ampersand

[−]

'&'

Apostrophe

[−]

'\''

ParenOpen

[−]

'('

ParenClose

[−]

')'

Asterisk

[−]

'*'

Plus

[−]

'+'

Comma

[−]

','

Minus

[−]

'-'

Dot

[−]

'.'

Slash

[−]

'/'

_0

[−]

'0'

_1

[−]

'1'

_2

[−]

'2'

_3

[−]

'3'

_4

[−]

'4'

_5

[−]

'5'

_6

[−]

'6'

_7

[−]

'7'

_8

[−]

'8'

_9

[−]

'9'

Colon

[−]

':'

Semicolon

[−]

';'

LessThan

[−]

'<'

Equal

[−]

'='

GreaterThan

[−]

'>'

Question

[−]

'?'

At

[−]

'@'

A

[−]

'A'

B

[−]

'B'

C

[−]

'C'

D

[−]

'D'

E

[−]

'E'

F

[−]

'F'

G

[−]

'G'

H

[−]

'H'

I

[−]

'I'

J

[−]

'J'

K

[−]

'K'

L

[−]

'L'

M

[−]

'M'

N

[−]

'N'

O

[−]

'O'

P

[−]

'P'

Q

[−]

'Q'

R

[−]

'R'

S

[−]

'S'

T

[−]

'T'

U

[−]

'U'

V

[−]

'V'

W

[−]

'W'

X

[−]

'X'

Y

[−]

'Y'

Z

[−]

'Z'

BracketOpen

[−]

'['

BackSlash

[−]

'\'

BracketClose

[−]

']'

Caret

[−]

'_'

UnderScore

[−]

'_'

Grave

[−]

'’`

a

[−]

'a'

b

[−]

'b'

c

[−]

'c'

d

[−]

'd'

e

[−]

'e'

f

[−]

'f'

g

[−]

'g'

h

[−]

'h'

i

[−]

'i'

j

[−]

'j'

k

[−]

'k'

l

[−]

'l'

m

[−]

'm'

n

[−]

'n'

o

[−]

'o'

p

[−]

'p'

q

[−]

'q'

r

[−]

'r'

s

[−]

's'

t

[−]

't'

u

[−]

'u'

v

[−]

'v'

w

[−]

'w'

x

[−]

'x'

y

[−]

'y'

z

[−]

'z'

CurlyBraceOpen

[−]

'{'

VerticalBar

[−]

'|'

CurlyBraceClose

[−]

'}'

Tilde

[−]

'~'

DEL

[−]

Delete

Implementations

`impl AsciiChar`[src][−]

`pub fn from<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError>`[src][−]

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`[src][−]

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

`pub fn as_byte(self) -> u8`[src][−]

Converts an ASCII character into a u8.

`pub fn as_char(self) -> char`[src][−]

Converts an ASCII character into a char.

`pub fn is_alphabetic(self) -> bool`[src][−]

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

`pub fn is_digit(self) -> bool`[src][−]

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

`pub fn is_alphanumeric(self) -> bool`[src][−]

Check if the character is a letter or number

`pub fn is_blank(self) -> bool`[src][−]

Check if the character is a space or horizontal tab

`pub fn is_whitespace(self) -> bool`[src][−]

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

`pub fn is_control(self) -> bool`[src][−]

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`[src][−]

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`[src][−]

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`[src][−]

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`[src][−]

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`[src][−]

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`[src][−]

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`[src][−]

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