Enum ascii::AsciiChar [−] [src]

#[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

Shift In

SO

Shift Out

DLE

Data Link Escape

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

Methods

`impl AsciiChar`
[src]

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

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

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

`fn as_byte(self) -> u8`

Converts an ASCII character into a u8.

`fn as_char(self) -> char`

Converts an ASCII character into a char.

`fn is_alphabetic(self) -> bool`

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

`fn is_digit(self) -> bool`

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

`fn is_alphanumeric(self) -> bool`

Check if the character is a letter or number

`fn is_blank(self) -> bool`

Check if the character is a space or horizontal tab

`fn is_whitespace(self) -> bool`

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

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

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

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

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

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

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

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

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

Trait Implementations

`impl Clone for AsciiChar`
[src]

`fn clone(&self) -> AsciiChar`

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl PartialEq for AsciiChar`
[src]

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

This method tests for self and other values to be equal, and is used by ==. Read more

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

This method tests for !=.

`impl PartialOrd for AsciiChar`
[src]

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

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

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

This method tests less than (for self and other) and is used by the < operator. Read more

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

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

This method tests greater than (for self and other) and is used by the > operator. Read more

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

`impl Ord for AsciiChar`
[src]

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

This method returns an Ordering between self and other. Read more

`impl Hash for AsciiChar`
[src]

`fn hash<H: Hasher>(&self, arg_0: &mut __H)`

Feeds this value into the given [Hasher]. Read more

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

Feeds a slice of this type into the given [Hasher]. Read more

`impl Copy for AsciiChar`
[src]

`impl Display for AsciiChar`
[src]

`fn fmt(&self, f: &mut Formatter) -> Result`

Formats the value using the given formatter. Read more

`impl Debug for AsciiChar`
[src]

`fn fmt(&self, f: &mut Formatter) -> Result`

Formats the value using the given formatter.

`impl AsciiExt for AsciiChar`
[src]

`type Owned = AsciiChar`

Container type for copied ASCII characters.

`fn is_ascii(&self) -> bool`

Checks if the value is within the ASCII range. Read more

`fn to_ascii_uppercase(&self) -> AsciiChar`

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

`fn to_ascii_lowercase(&self) -> AsciiChar`

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

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

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

`fn make_ascii_uppercase(&mut self)`

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