| // #[allow(deprecated)] doesn't silence warnings on the method invocations, |
| // which would call the inherent methods if AsciiExt wasn't in scope. |
| #![cfg_attr(feature = "std", allow(deprecated))] |
| |
| #[cfg(feature = "quickcheck")] |
| use quickcheck::{Arbitrary, Gen}; |
| |
| use core::mem; |
| use core::cmp::Ordering; |
| use core::{fmt, char}; |
| #[cfg(feature = "std")] |
| use std::error::Error; |
| #[cfg(feature = "std")] |
| use std::ascii::AsciiExt; |
| |
| #[allow(non_camel_case_types)] |
| /// An ASCII character. It wraps a `u8`, with the highest bit always zero. |
| #[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Hash, Copy)] |
| #[repr(u8)] |
| pub enum AsciiChar { |
| /// `'\0'` |
| Null = 0, |
| /// [Start Of Heading](http://en.wikipedia.org/wiki/Start_of_Heading) |
| SOH = 1, |
| /// [Start Of teXt](http://en.wikipedia.org/wiki/Start_of_Text) |
| SOX = 2, |
| /// [End of TeXt](http://en.wikipedia.org/wiki/End-of-Text_character) |
| ETX = 3, |
| /// [End Of Transmission](http://en.wikipedia.org/wiki/End-of-Transmission_character) |
| EOT = 4, |
| /// [Enquiry](http://en.wikipedia.org/wiki/Enquiry_character) |
| ENQ = 5, |
| /// [Acknowledgement](http://en.wikipedia.org/wiki/Acknowledge_character) |
| ACK = 6, |
| /// [bell / alarm / audible](http://en.wikipedia.org/wiki/Bell_character) |
| /// |
| /// `'\a'` is not recognized by Rust. |
| Bell = 7, |
| /// [Backspace](http://en.wikipedia.org/wiki/Backspace) |
| /// |
| /// `'\b'` is not recognized by Rust. |
| BackSpace = 8, |
| /// `'\t'` |
| Tab = 9, |
| /// `'\n'` |
| LineFeed = 10, |
| /// [Vertical tab](http://en.wikipedia.org/wiki/Vertical_Tab) |
| /// |
| /// `'\v'` is not recognized by Rust. |
| VT = 11, |
| /// [Form Feed](http://en.wikipedia.org/wiki/Form_Feed) |
| /// |
| /// `'\f'` is not recognized by Rust. |
| FF = 12, |
| /// `'\r'` |
| CarriageReturn = 13, |
| /// [Shift In](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) |
| SI = 14, |
| /// [Shift Out](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters) |
| SO = 15, |
| /// [Data Link Escape](http://en.wikipedia.org/wiki/Data_Link_Escape) |
| DLE = 16, |
| /// [Device control 1, often XON](http://en.wikipedia.org/wiki/Device_Control_1) |
| DC1 = 17, |
| /// Device control 2 |
| DC2 = 18, |
| /// Device control 3, Often XOFF |
| DC3 = 19, |
| /// Device control 4 |
| DC4 = 20, |
| /// [Negative AcKnowledgement](http://en.wikipedia.org/wiki/Negative-acknowledge_character) |
| NAK = 21, |
| /// [Synchronous idle](http://en.wikipedia.org/wiki/Synchronous_Idle) |
| SYN = 22, |
| /// [End of Transmission Block](http://en.wikipedia.org/wiki/End-of-Transmission-Block_character) |
| ETB = 23, |
| /// [Cancel](http://en.wikipedia.org/wiki/Cancel_character) |
| CAN = 24, |
| /// [End of Medium](http://en.wikipedia.org/wiki/End_of_Medium) |
| EM = 25, |
| /// [Substitute](http://en.wikipedia.org/wiki/Substitute_character) |
| SUB = 26, |
| /// [Escape](http://en.wikipedia.org/wiki/Escape_character) |
| /// |
| /// `'\e'` is not recognized by Rust. |
| ESC = 27, |
| /// [File Separator](http://en.wikipedia.org/wiki/File_separator) |
| FS = 28, |
| /// [Group Separator](http://en.wikipedia.org/wiki/Group_separator) |
| GS = 29, |
| /// [Record Separator](http://en.wikipedia.org/wiki/Record_separator) |
| RS = 30, |
| /// [Unit Separator](http://en.wikipedia.org/wiki/Unit_separator) |
| 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'` |
| _0 = 48, |
| /// `'1'` |
| _1 = 49, |
| /// `'2'` |
| _2 = 50, |
| /// `'3'` |
| _3 = 51, |
| /// `'4'` |
| _4 = 52, |
| /// `'5'` |
| _5 = 53, |
| /// `'6'` |
| _6 = 54, |
| /// `'7'` |
| _7 = 55, |
| /// `'8'` |
| _8 = 56, |
| /// `'9'` |
| _9 = 57, |
| /// `':'` |
| Colon = 58, |
| /// `';'` |
| Semicolon = 59, |
| /// `'<'` |
| LessThan = 60, |
| /// `'='` |
| Equal = 61, |
| /// `'>'` |
| GreaterThan = 62, |
| /// `'?'` |
| Question = 63, |
| /// `'@'` |
| At = 64, |
| /// `'A'` |
| A = 65, |
| /// `'B'` |
| B = 66, |
| /// `'C'` |
| C = 67, |
| /// `'D'` |
| D = 68, |
| /// `'E'` |
| E = 69, |
| /// `'F'` |
| F = 70, |
| /// `'G'` |
| G = 71, |
| /// `'H'` |
| H = 72, |
| /// `'I'` |
| I = 73, |
| /// `'J'` |
| J = 74, |
| /// `'K'` |
| K = 75, |
| /// `'L'` |
| L = 76, |
| /// `'M'` |
| M = 77, |
| /// `'N'` |
| N = 78, |
| /// `'O'` |
| O = 79, |
| /// `'P'` |
| P = 80, |
| /// `'Q'` |
| Q = 81, |
| /// `'R'` |
| R = 82, |
| /// `'S'` |
| S = 83, |
| /// `'T'` |
| T = 84, |
| /// `'U'` |
| U = 85, |
| /// `'V'` |
| V = 86, |
| /// `'W'` |
| W = 87, |
| /// `'X'` |
| X = 88, |
| /// `'Y'` |
| Y = 89, |
| /// `'Z'` |
| Z = 90, |
| /// `'['` |
| BracketOpen = 91, |
| /// `'\'` |
| BackSlash = 92, |
| /// `']'` |
| BracketClose = 93, |
| /// `'_'` |
| Caret = 94, |
| /// `'_'` |
| UnderScore = 95, |
| /// `'`'` |
| Grave = 96, |
| /// `'a'` |
| a = 97, |
| /// `'b'` |
| b = 98, |
| /// `'c'` |
| c = 99, |
| /// `'d'` |
| d = 100, |
| /// `'e'` |
| e = 101, |
| /// `'f'` |
| f = 102, |
| /// `'g'` |
| g = 103, |
| /// `'h'` |
| h = 104, |
| /// `'i'` |
| i = 105, |
| /// `'j'` |
| j = 106, |
| /// `'k'` |
| k = 107, |
| /// `'l'` |
| l = 108, |
| /// `'m'` |
| m = 109, |
| /// `'n'` |
| n = 110, |
| /// `'o'` |
| o = 111, |
| /// `'p'` |
| p = 112, |
| /// `'q'` |
| q = 113, |
| /// `'r'` |
| r = 114, |
| /// `'s'` |
| s = 115, |
| /// `'t'` |
| t = 116, |
| /// `'u'` |
| u = 117, |
| /// `'v'` |
| v = 118, |
| /// `'w'` |
| w = 119, |
| /// `'x'` |
| x = 120, |
| /// `'y'` |
| y = 121, |
| /// `'z'` |
| z = 122, |
| /// `'{'` |
| CurlyBraceOpen = 123, |
| /// `'|'` |
| VerticalBar = 124, |
| /// `'}'` |
| CurlyBraceClose = 125, |
| /// `'~'` |
| Tilde = 126, |
| /// [Delete](http://en.wikipedia.org/wiki/Delete_character) |
| DEL = 127, |
| } |
| |
| impl AsciiChar { |
| /// Constructs an ASCII character from a `u8`, `char` or other character type. |
| /// |
| /// # Failure |
| /// Returns `Err(())` if the character can't be ASCII encoded. |
| /// |
| /// # Example |
| /// ``` |
| /// # use ascii::AsciiChar; |
| /// let a = AsciiChar::from('g').unwrap(); |
| /// assert_eq!(a.as_char(), 'g'); |
| /// ``` |
| #[inline] |
| pub fn from<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError> { |
| ch.to_ascii_char() |
| } |
| |
| /// Constructs an ASCII character from a `char` or `u8` without any checks. |
| #[inline] |
| pub unsafe fn from_unchecked<C: ToAsciiChar>(ch: C) -> Self { |
| ch.to_ascii_char_unchecked() |
| } |
| |
| /// Converts an ASCII character into a `u8`. |
| #[inline] |
| pub fn as_byte(self) -> u8 { |
| self as u8 |
| } |
| |
| /// Converts an ASCII character into a `char`. |
| #[inline] |
| pub fn as_char(self) -> char { |
| self.as_byte() as char |
| } |
| |
| // the following methods are like ctype, and the implementation is inspired by musl |
| |
| /// Check if the character is a letter (a-z, A-Z) |
| #[inline] |
| pub fn is_alphabetic(self) -> bool { |
| let c = self.as_byte() | 0b010_0000; // Turns uppercase into lowercase. |
| c >= b'a' && c <= b'z' |
| } |
| |
| /// Check if the character is a number (0-9) |
| #[inline] |
| pub fn is_digit(self) -> bool { |
| self >= AsciiChar::_0 && self <= AsciiChar::_9 |
| } |
| |
| /// Check if the character is a letter or number |
| #[inline] |
| pub fn is_alphanumeric(self) -> bool { |
| self.is_alphabetic() || self.is_digit() |
| } |
| |
| /// Check if the character is a space or horizontal tab |
| #[inline] |
| pub fn is_blank(self) -> bool { |
| self == AsciiChar::Space || self == AsciiChar::Tab |
| } |
| |
| /// Check if the character is a ' ', '\t', '\n' or '\r' |
| #[inline] |
| pub fn is_whitespace(self) -> bool { |
| self.is_blank() || self == AsciiChar::LineFeed || self == AsciiChar::CarriageReturn |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_control(self) -> bool { |
| self < AsciiChar::Space || self == AsciiChar::DEL |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_graph(self) -> bool { |
| self.as_byte().wrapping_sub(b' ' + 1) < 0x5E |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_print(self) -> bool { |
| self.as_byte().wrapping_sub(b' ') < 0x5F |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_lowercase(self) -> bool { |
| self.as_byte().wrapping_sub(b'a') < 26 |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_uppercase(self) -> bool { |
| self.as_byte().wrapping_sub(b'A') < 26 |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_punctuation(self) -> bool { |
| self.is_graph() && !self.is_alphanumeric() |
| } |
| |
| /// 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); |
| /// ``` |
| #[inline] |
| pub fn is_hex(self) -> bool { |
| self.is_digit() || (self.as_byte() | 0x20u8).wrapping_sub(b'a') < 6 |
| } |
| |
| /// 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 |
| /// ``` |
| /// # use ascii::ToAsciiChar; |
| /// 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 as_printable_char(self) -> char { |
| unsafe { |
| match self as u8 { |
| b' '...b'~' => self.as_char(), |
| 127 => '␡', |
| _ => char::from_u32_unchecked(self as u32 + '␀' as u32), |
| } |
| } |
| } |
| |
| /// Replaces letters `a` to `z` with `A` to `Z` |
| pub fn make_ascii_uppercase(&mut self) { |
| *self = self.to_ascii_uppercase() |
| } |
| |
| /// Replaces letters `A` to `Z` with `a` to `z` |
| pub fn make_ascii_lowercase(&mut self) { |
| *self = self.to_ascii_lowercase() |
| } |
| |
| /// Maps letters `a`...`z` to `A`...`Z` and returns everything else unchanged. |
| #[inline] |
| pub fn to_ascii_uppercase(&self) -> Self { |
| unsafe { |
| match *self as u8 { |
| b'a'...b'z' => AsciiChar::from_unchecked(self.as_byte() - (b'a' - b'A')), |
| _ => *self, |
| } |
| } |
| } |
| |
| /// Maps letters `A`...`Z` to `a`...`z` and returns everything else unchanged. |
| #[inline] |
| pub fn to_ascii_lowercase(&self) -> Self { |
| unsafe { |
| match *self as u8 { |
| b'A'...b'Z' => AsciiChar::from_unchecked(self.as_byte() + (b'a' - b'A')), |
| _ => *self, |
| } |
| } |
| } |
| |
| /// Compares two characters case-insensitively. |
| pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool { |
| self.to_ascii_lowercase() == other.to_ascii_lowercase() |
| } |
| } |
| |
| impl fmt::Display for AsciiChar { |
| #[inline] |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| self.as_char().fmt(f) |
| } |
| } |
| |
| impl fmt::Debug for AsciiChar { |
| #[inline] |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| self.as_char().fmt(f) |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| impl AsciiExt for AsciiChar { |
| type Owned = AsciiChar; |
| |
| #[inline] |
| fn is_ascii(&self) -> bool { |
| true |
| } |
| |
| #[inline] |
| fn to_ascii_uppercase(&self) -> AsciiChar { |
| unsafe { |
| self.as_byte() |
| .to_ascii_uppercase() |
| .to_ascii_char_unchecked() |
| } |
| } |
| |
| #[inline] |
| fn to_ascii_lowercase(&self) -> AsciiChar { |
| unsafe { |
| self.as_byte() |
| .to_ascii_lowercase() |
| .to_ascii_char_unchecked() |
| } |
| } |
| |
| fn eq_ignore_ascii_case(&self, other: &Self) -> bool { |
| self.as_byte().eq_ignore_ascii_case(&other.as_byte()) |
| } |
| |
| #[inline] |
| fn make_ascii_uppercase(&mut self) { |
| *self = self.to_ascii_uppercase(); |
| } |
| |
| #[inline] |
| fn make_ascii_lowercase(&mut self) { |
| *self = self.to_ascii_lowercase(); |
| } |
| } |
| |
| macro_rules! impl_into_partial_eq_ord {($wider:ty, $to_wider:expr) => { |
| impl From<AsciiChar> for $wider { |
| #[inline] |
| fn from(a: AsciiChar) -> $wider { |
| $to_wider(a) |
| } |
| } |
| impl PartialEq<$wider> for AsciiChar { |
| #[inline] |
| fn eq(&self, rhs: &$wider) -> bool { |
| $to_wider(*self) == *rhs |
| } |
| } |
| impl PartialEq<AsciiChar> for $wider { |
| #[inline] |
| fn eq(&self, rhs: &AsciiChar) -> bool { |
| *self == $to_wider(*rhs) |
| } |
| } |
| impl PartialOrd<$wider> for AsciiChar { |
| #[inline] |
| fn partial_cmp(&self, rhs: &$wider) -> Option<Ordering> { |
| $to_wider(*self).partial_cmp(rhs) |
| } |
| } |
| impl PartialOrd<AsciiChar> for $wider { |
| #[inline] |
| fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering> { |
| self.partial_cmp(&$to_wider(*rhs)) |
| } |
| } |
| }} |
| impl_into_partial_eq_ord!{u8, AsciiChar::as_byte} |
| impl_into_partial_eq_ord!{char, AsciiChar::as_char} |
| |
| |
| /// Error returned by `ToAsciiChar`. |
| #[derive(PartialEq)] |
| pub struct ToAsciiCharError(()); |
| |
| const ERRORMSG_CHAR: &'static str = "not an ASCII character"; |
| |
| #[cfg(not(feature = "std"))] |
| impl ToAsciiCharError { |
| /// Returns a description for this error, like `std::error::Error::description`. |
| #[inline] |
| pub fn description(&self) -> &'static str { |
| ERRORMSG_CHAR |
| } |
| } |
| |
| impl fmt::Debug for ToAsciiCharError { |
| fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { |
| write!(fmtr, "{}", ERRORMSG_CHAR) |
| } |
| } |
| |
| impl fmt::Display for ToAsciiCharError { |
| fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result { |
| write!(fmtr, "{}", ERRORMSG_CHAR) |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| impl Error for ToAsciiCharError { |
| #[inline] |
| fn description(&self) -> &'static str { |
| ERRORMSG_CHAR |
| } |
| } |
| |
| /// Convert `char`, `u8` and other character types to `AsciiChar`. |
| pub trait ToAsciiChar { |
| /// Convert to `AsciiChar` without checking that it is an ASCII character. |
| unsafe fn to_ascii_char_unchecked(self) -> AsciiChar; |
| /// Convert to `AsciiChar`. |
| fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError>; |
| } |
| |
| impl ToAsciiChar for AsciiChar { |
| #[inline] |
| fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> { |
| Ok(self) |
| } |
| #[inline] |
| unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { |
| self |
| } |
| } |
| |
| impl ToAsciiChar for u8 { |
| #[inline] |
| fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> { |
| unsafe { |
| if self <= 0x7F { |
| return Ok(self.to_ascii_char_unchecked()); |
| } |
| } |
| Err(ToAsciiCharError(())) |
| } |
| #[inline] |
| unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { |
| mem::transmute(self) |
| } |
| } |
| |
| impl ToAsciiChar for char { |
| #[inline] |
| fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> { |
| unsafe { |
| if self as u32 <= 0x7F { |
| return Ok(self.to_ascii_char_unchecked()); |
| } |
| } |
| Err(ToAsciiCharError(())) |
| } |
| #[inline] |
| unsafe fn to_ascii_char_unchecked(self) -> AsciiChar { |
| (self as u8).to_ascii_char_unchecked() |
| } |
| } |
| |
| #[cfg(feature = "quickcheck")] |
| impl Arbitrary for AsciiChar { |
| fn arbitrary<G: Gen>(g: &mut G) -> Self { |
| let mode = g.gen_range(0, 100); |
| match mode { |
| 0...14 => { |
| // Control characters |
| unsafe { AsciiChar::from_unchecked(g.gen_range(0, 0x1F) as u8) } |
| } |
| 15...39 => { |
| // Characters often used in programming languages |
| *g.choose(&[ |
| AsciiChar::Space, AsciiChar::Tab, AsciiChar::LineFeed, AsciiChar::Tilde, |
| AsciiChar::Grave, AsciiChar::Exclamation, AsciiChar::At, AsciiChar::Hash, |
| AsciiChar::Dollar, AsciiChar::Percent, AsciiChar::Ampersand, |
| AsciiChar::Asterisk, AsciiChar::ParenOpen, AsciiChar::ParenClose, |
| AsciiChar::UnderScore, AsciiChar::Minus, AsciiChar::Equal, AsciiChar::Plus, |
| AsciiChar::BracketOpen, AsciiChar::BracketClose, AsciiChar::CurlyBraceOpen, |
| AsciiChar::CurlyBraceClose, AsciiChar::Colon, AsciiChar::Semicolon, |
| AsciiChar::Apostrophe, AsciiChar::Quotation, AsciiChar::BackSlash, |
| AsciiChar::VerticalBar, AsciiChar::Caret, AsciiChar::Comma, AsciiChar::LessThan, |
| AsciiChar::GreaterThan, AsciiChar::Dot, AsciiChar::Slash, AsciiChar::Question, |
| AsciiChar::_0, AsciiChar::_1, AsciiChar::_2, AsciiChar::_3, AsciiChar::_3, |
| AsciiChar::_4 , AsciiChar::_6, AsciiChar::_7, AsciiChar::_8, AsciiChar::_9, |
| ]).unwrap() |
| } |
| 40...99 => { |
| // Completely arbitrary characters |
| unsafe { AsciiChar::from_unchecked(g.gen_range(0, 0x7F) as u8) } |
| } |
| _ => unreachable!(), |
| } |
| } |
| |
| fn shrink(&self) -> Box<Iterator<Item = Self>> { |
| Box::new((*self as u8).shrink().filter_map( |
| |x| AsciiChar::from(x).ok(), |
| )) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::{AsciiChar, ToAsciiChar, ToAsciiCharError}; |
| use AsciiChar::*; |
| |
| #[test] |
| fn to_ascii_char() { |
| fn generic<C: ToAsciiChar>(ch: C) -> Result<AsciiChar, ToAsciiCharError> { |
| ch.to_ascii_char() |
| } |
| assert_eq!(generic(A), Ok(A)); |
| assert_eq!(generic(b'A'), Ok(A)); |
| assert_eq!(generic('A'), Ok(A)); |
| assert!(generic(200).is_err()); |
| assert!(generic('λ').is_err()); |
| } |
| |
| #[test] |
| fn as_byte_and_char() { |
| assert_eq!(A.as_byte(), b'A'); |
| assert_eq!(A.as_char(), 'A'); |
| } |
| |
| #[test] |
| fn is_digit() { |
| assert_eq!('0'.to_ascii_char().unwrap().is_digit(), true); |
| assert_eq!('9'.to_ascii_char().unwrap().is_digit(), true); |
| assert_eq!('/'.to_ascii_char().unwrap().is_digit(), false); |
| assert_eq!(':'.to_ascii_char().unwrap().is_digit(), false); |
| } |
| |
| #[test] |
| fn is_control() { |
| assert_eq!(US.is_control(), true); |
| assert_eq!(DEL.is_control(), true); |
| assert_eq!(Space.is_control(), false); |
| } |
| |
| #[test] |
| fn cmp_wider() { |
| assert_eq!(A, 'A'); |
| assert_eq!(b'b', b); |
| assert!(a < 'z'); |
| } |
| |
| #[test] |
| fn ascii_case() { |
| assert_eq!(At.to_ascii_lowercase(), At); |
| assert_eq!(At.to_ascii_uppercase(), At); |
| assert_eq!(A.to_ascii_lowercase(), a); |
| assert_eq!(A.to_ascii_uppercase(), A); |
| assert_eq!(a.to_ascii_lowercase(), a); |
| assert_eq!(a.to_ascii_uppercase(), A); |
| |
| assert!(LineFeed.eq_ignore_ascii_case(&LineFeed)); |
| assert!(!LineFeed.eq_ignore_ascii_case(&CarriageReturn)); |
| assert!(z.eq_ignore_ascii_case(&Z)); |
| assert!(Z.eq_ignore_ascii_case(&z)); |
| assert!(!Z.eq_ignore_ascii_case(&DEL)); |
| } |
| |
| #[test] |
| #[cfg(feature = "std")] |
| fn ascii_ext() { |
| #[allow(deprecated)] |
| use std::ascii::AsciiExt; |
| assert!(AsciiExt::is_ascii(&Null)); |
| assert!(AsciiExt::is_ascii(&DEL)); |
| assert!(AsciiExt::eq_ignore_ascii_case(&a, &A)); |
| assert!(!AsciiExt::eq_ignore_ascii_case(&A, &At)); |
| assert_eq!(AsciiExt::to_ascii_lowercase(&A), a); |
| assert_eq!(AsciiExt::to_ascii_uppercase(&A), A); |
| assert_eq!(AsciiExt::to_ascii_lowercase(&a), a); |
| assert_eq!(AsciiExt::to_ascii_uppercase(&a), A); |
| assert_eq!(AsciiExt::to_ascii_lowercase(&At), At); |
| assert_eq!(AsciiExt::to_ascii_uppercase(&At), At); |
| let mut mutable = (A,a); |
| AsciiExt::make_ascii_lowercase(&mut mutable.0); |
| AsciiExt::make_ascii_uppercase(&mut mutable.1); |
| assert_eq!(mutable.0, a); |
| assert_eq!(mutable.1, A); |
| } |
| |
| #[test] |
| #[cfg(feature = "std")] |
| fn fmt_ascii() { |
| assert_eq!(format!("{}", t), "t"); |
| assert_eq!(format!("{:?}", t), "'t'"); |
| assert_eq!(format!("{}", LineFeed), "\n"); |
| assert_eq!(format!("{:?}", LineFeed), "'\\n'"); |
| } |
| } |
