Enum ascii::AsciiChar

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

Start Of Heading

SOX

Start Of teXt

ETX

End of TeXt

EOT

End Of Transmission

ENQ

Enquiry

ACK

Acknowledgement

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

Cancel

EM

End of Medium

SUB

Substitute

ESC

Escape

'\e' is not recognized by Rust.

FS

File Separator

GS

Group Separator

RS

Record Separator

US

Unit Separator

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

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

Trait Implementations

impl Copy for AsciiChar

impl Hash for AsciiChar

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

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

impl Eq for AsciiChar

impl Ord for AsciiChar

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

This method returns an Ordering between self and other.

impl PartialOrd for AsciiChar

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

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

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

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

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

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

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

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

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

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

impl PartialEq for AsciiChar

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

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

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

This method tests for !=.

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 Display for AsciiChar

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

Formats the value using the given formatter.

impl Debug for AsciiChar

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

Formats the value using the given formatter.

impl AsciiExt for AsciiChar

type Owned = AsciiChar

Container type for copied ASCII characters.

fn is_ascii(&self) -> bool

Checks if the value is within the ASCII range.

fn to_ascii_uppercase(&self) -> AsciiChar

Makes a copy of the string in ASCII upper case.

fn to_ascii_lowercase(&self) -> AsciiChar

Makes a copy of the string in ASCII lower case.

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

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

fn make_ascii_uppercase(&mut self)

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

fn make_ascii_lowercase(&mut self)

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

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.