Add all methods of AsciiExt to u8 directly
This is the first step in order to deprecate AsciiExt. Since this is a WIP commit, there is still some code duplication (notably the static arrays) that will be removed later.
This commit is contained in:
Lukas Kalbertodt
parent
525b81d570
commit
d3f2be4bd8
@ -2257,6 +2257,558 @@ impl u8 {
|
||||
intrinsics::add_with_overflow,
|
||||
intrinsics::sub_with_overflow,
|
||||
intrinsics::mul_with_overflow }
|
||||
|
||||
|
||||
/// Checks if the value is within the ASCII range.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let ascii = 97u8;
|
||||
/// let non_ascii = 150u8;
|
||||
///
|
||||
/// assert!(ascii.is_ascii());
|
||||
/// assert!(!non_ascii.is_ascii());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii(&self) -> bool {
|
||||
*self & 128 == 0
|
||||
}
|
||||
|
||||
/// Makes a copy of the value in its ASCII upper case equivalent.
|
||||
///
|
||||
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
|
||||
/// but non-ASCII letters are unchanged.
|
||||
///
|
||||
/// To uppercase the value in-place, use [`make_ascii_uppercase`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let lowercase_a = 97u8;
|
||||
///
|
||||
/// assert_eq!(65, lowercase_a.to_ascii_uppercase());
|
||||
/// ```
|
||||
///
|
||||
/// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn to_ascii_uppercase(&self) -> u8 {
|
||||
ASCII_UPPERCASE_MAP[*self as usize]
|
||||
}
|
||||
|
||||
/// Makes a copy of the value in its ASCII lower case equivalent.
|
||||
///
|
||||
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
|
||||
/// but non-ASCII letters are unchanged.
|
||||
///
|
||||
/// To lowercase the value in-place, use [`make_ascii_lowercase`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = 65u8;
|
||||
///
|
||||
/// assert_eq!(97, uppercase_a.to_ascii_lowercase());
|
||||
/// ```
|
||||
///
|
||||
/// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn to_ascii_lowercase(&self) -> u8 {
|
||||
ASCII_LOWERCASE_MAP[*self as usize]
|
||||
}
|
||||
|
||||
/// Checks that two values are an ASCII case-insensitive match.
|
||||
///
|
||||
/// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
|
||||
/// but without allocating and copying temporaries.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let lowercase_a = 97u8;
|
||||
/// let uppercase_a = 65u8;
|
||||
///
|
||||
/// assert!(lowercase_a.eq_ignore_ascii_case(uppercase_a));
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn eq_ignore_ascii_case(&self, other: u8) -> bool {
|
||||
self.to_ascii_lowercase() == other.to_ascii_lowercase()
|
||||
}
|
||||
|
||||
/// Converts this value to its ASCII upper case equivalent in-place.
|
||||
///
|
||||
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
|
||||
/// but non-ASCII letters are unchanged.
|
||||
///
|
||||
/// To return a new uppercased value without modifying the existing one, use
|
||||
/// [`to_ascii_uppercase`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let mut byte = b'a';
|
||||
///
|
||||
/// byte.make_ascii_uppercase();
|
||||
///
|
||||
/// assert_eq!(b'A', byte);
|
||||
/// ```
|
||||
///
|
||||
/// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn make_ascii_uppercase(&mut self) {
|
||||
*self = self.to_ascii_uppercase();
|
||||
}
|
||||
|
||||
/// Converts this value to its ASCII lower case equivalent in-place.
|
||||
///
|
||||
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
|
||||
/// but non-ASCII letters are unchanged.
|
||||
///
|
||||
/// To return a new lowercased value without modifying the existing one, use
|
||||
/// [`to_ascii_lowercase`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let mut byte = b'A';
|
||||
///
|
||||
/// byte.make_ascii_lowercase();
|
||||
///
|
||||
/// assert_eq!(b'a', byte);
|
||||
/// ```
|
||||
///
|
||||
/// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn make_ascii_lowercase(&mut self) {
|
||||
*self = self.to_ascii_lowercase();
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII alphabetic character:
|
||||
///
|
||||
/// - U+0041 'A' ... U+005A 'Z', or
|
||||
/// - U+0061 'a' ... U+007A 'z'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(uppercase_a.is_ascii_alphabetic());
|
||||
/// assert!(uppercase_g.is_ascii_alphabetic());
|
||||
/// assert!(a.is_ascii_alphabetic());
|
||||
/// assert!(g.is_ascii_alphabetic());
|
||||
/// assert!(!zero.is_ascii_alphabetic());
|
||||
/// assert!(!percent.is_ascii_alphabetic());
|
||||
/// assert!(!space.is_ascii_alphabetic());
|
||||
/// assert!(!lf.is_ascii_alphabetic());
|
||||
/// assert!(!esc.is_ascii_alphabetic());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_alphabetic(&self) -> bool {
|
||||
if *self >= 0x80 { return false; }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
L | Lx | U | Ux => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII uppercase character:
|
||||
/// U+0041 'A' ... U+005A 'Z'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(uppercase_a.is_ascii_uppercase());
|
||||
/// assert!(uppercase_g.is_ascii_uppercase());
|
||||
/// assert!(!a.is_ascii_uppercase());
|
||||
/// assert!(!g.is_ascii_uppercase());
|
||||
/// assert!(!zero.is_ascii_uppercase());
|
||||
/// assert!(!percent.is_ascii_uppercase());
|
||||
/// assert!(!space.is_ascii_uppercase());
|
||||
/// assert!(!lf.is_ascii_uppercase());
|
||||
/// assert!(!esc.is_ascii_uppercase());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_uppercase(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
U | Ux => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII lowercase character:
|
||||
/// U+0061 'a' ... U+007A 'z'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(!uppercase_a.is_ascii_lowercase());
|
||||
/// assert!(!uppercase_g.is_ascii_lowercase());
|
||||
/// assert!(a.is_ascii_lowercase());
|
||||
/// assert!(g.is_ascii_lowercase());
|
||||
/// assert!(!zero.is_ascii_lowercase());
|
||||
/// assert!(!percent.is_ascii_lowercase());
|
||||
/// assert!(!space.is_ascii_lowercase());
|
||||
/// assert!(!lf.is_ascii_lowercase());
|
||||
/// assert!(!esc.is_ascii_lowercase());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_lowercase(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
L | Lx => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII alphanumeric character:
|
||||
///
|
||||
/// - U+0041 'A' ... U+005A 'Z', U+0061 'a' ... U+007A 'z', or
|
||||
/// - U+0030 '0' ... U+0039 '9'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(uppercase_a.is_ascii_alphanumeric());
|
||||
/// assert!(uppercase_g.is_ascii_alphanumeric());
|
||||
/// assert!(a.is_ascii_alphanumeric());
|
||||
/// assert!(g.is_ascii_alphanumeric());
|
||||
/// assert!(zero.is_ascii_alphanumeric());
|
||||
/// assert!(!percent.is_ascii_alphanumeric());
|
||||
/// assert!(!space.is_ascii_alphanumeric());
|
||||
/// assert!(!lf.is_ascii_alphanumeric());
|
||||
/// assert!(!esc.is_ascii_alphanumeric());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_alphanumeric(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
D | L | Lx | U | Ux => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII decimal digit:
|
||||
/// U+0030 '0' ... U+0039 '9'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(!uppercase_a.is_ascii_digit());
|
||||
/// assert!(!uppercase_g.is_ascii_digit());
|
||||
/// assert!(!a.is_ascii_digit());
|
||||
/// assert!(!g.is_ascii_digit());
|
||||
/// assert!(zero.is_ascii_digit());
|
||||
/// assert!(!percent.is_ascii_digit());
|
||||
/// assert!(!space.is_ascii_digit());
|
||||
/// assert!(!lf.is_ascii_digit());
|
||||
/// assert!(!esc.is_ascii_digit());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_digit(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
D => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII hexadecimal digit:
|
||||
///
|
||||
/// - U+0030 '0' ... U+0039 '9', U+0041 'A' ... U+0046 'F', or
|
||||
/// - U+0061 'a' ... U+0066 'f'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(uppercase_a.is_ascii_hexdigit());
|
||||
/// assert!(!uppercase_g.is_ascii_hexdigit());
|
||||
/// assert!(a.is_ascii_hexdigit());
|
||||
/// assert!(!g.is_ascii_hexdigit());
|
||||
/// assert!(zero.is_ascii_hexdigit());
|
||||
/// assert!(!percent.is_ascii_hexdigit());
|
||||
/// assert!(!space.is_ascii_hexdigit());
|
||||
/// assert!(!lf.is_ascii_hexdigit());
|
||||
/// assert!(!esc.is_ascii_hexdigit());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_hexdigit(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
D | Lx | Ux => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII punctuation character:
|
||||
///
|
||||
/// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
|
||||
/// - U+003A ... U+0040 `: ; < = > ? @`, or
|
||||
/// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
|
||||
/// - U+007B ... U+007E `{ | } ~`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(!uppercase_a.is_ascii_punctuation());
|
||||
/// assert!(!uppercase_g.is_ascii_punctuation());
|
||||
/// assert!(!a.is_ascii_punctuation());
|
||||
/// assert!(!g.is_ascii_punctuation());
|
||||
/// assert!(!zero.is_ascii_punctuation());
|
||||
/// assert!(percent.is_ascii_punctuation());
|
||||
/// assert!(!space.is_ascii_punctuation());
|
||||
/// assert!(!lf.is_ascii_punctuation());
|
||||
/// assert!(!esc.is_ascii_punctuation());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_punctuation(&self) -> bool {
|
||||
if *self >= 0x80 { return false }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
P => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII graphic character:
|
||||
/// U+0021 '@' ... U+007E '~'.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(uppercase_a.is_ascii_graphic());
|
||||
/// assert!(uppercase_g.is_ascii_graphic());
|
||||
/// assert!(a.is_ascii_graphic());
|
||||
/// assert!(g.is_ascii_graphic());
|
||||
/// assert!(zero.is_ascii_graphic());
|
||||
/// assert!(percent.is_ascii_graphic());
|
||||
/// assert!(!space.is_ascii_graphic());
|
||||
/// assert!(!lf.is_ascii_graphic());
|
||||
/// assert!(!esc.is_ascii_graphic());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_graphic(&self) -> bool {
|
||||
if *self >= 0x80 { return false; }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
Ux | U | Lx | L | D | P => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII whitespace character:
|
||||
/// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
|
||||
/// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
|
||||
///
|
||||
/// Rust uses the WhatWG Infra Standard's [definition of ASCII
|
||||
/// whitespace][infra-aw]. There are several other definitions in
|
||||
/// wide use. For instance, [the POSIX locale][pct] includes
|
||||
/// U+000B VERTICAL TAB as well as all the above characters,
|
||||
/// but—from the very same specification—[the default rule for
|
||||
/// "field splitting" in the Bourne shell][bfs] considers *only*
|
||||
/// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
|
||||
///
|
||||
/// If you are writing a program that will process an existing
|
||||
/// file format, check what that format's definition of whitespace is
|
||||
/// before using this function.
|
||||
///
|
||||
/// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
|
||||
/// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
|
||||
/// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(!uppercase_a.is_ascii_whitespace());
|
||||
/// assert!(!uppercase_g.is_ascii_whitespace());
|
||||
/// assert!(!a.is_ascii_whitespace());
|
||||
/// assert!(!g.is_ascii_whitespace());
|
||||
/// assert!(!zero.is_ascii_whitespace());
|
||||
/// assert!(!percent.is_ascii_whitespace());
|
||||
/// assert!(space.is_ascii_whitespace());
|
||||
/// assert!(lf.is_ascii_whitespace());
|
||||
/// assert!(!esc.is_ascii_whitespace());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_whitespace(&self) -> bool {
|
||||
if *self >= 0x80 { return false; }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
Cw|W => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if the value is an ASCII control character:
|
||||
/// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.
|
||||
/// Note that most ASCII whitespace characters are control
|
||||
/// characters, but SPACE is not.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(ascii_methods_on_intrinsics)]
|
||||
///
|
||||
/// let uppercase_a = b'A';
|
||||
/// let uppercase_g = b'G';
|
||||
/// let a = b'a';
|
||||
/// let g = b'g';
|
||||
/// let zero = b'0';
|
||||
/// let percent = b'%';
|
||||
/// let space = b' ';
|
||||
/// let lf = b'\n';
|
||||
/// let esc = 0x1b_u8;
|
||||
///
|
||||
/// assert!(!uppercase_a.is_ascii_control());
|
||||
/// assert!(!uppercase_g.is_ascii_control());
|
||||
/// assert!(!a.is_ascii_control());
|
||||
/// assert!(!g.is_ascii_control());
|
||||
/// assert!(!zero.is_ascii_control());
|
||||
/// assert!(!percent.is_ascii_control());
|
||||
/// assert!(!space.is_ascii_control());
|
||||
/// assert!(lf.is_ascii_control());
|
||||
/// assert!(esc.is_ascii_control());
|
||||
/// ```
|
||||
#[unstable(feature = "ascii_methods_on_intrinsics", issue = "0")]
|
||||
#[inline]
|
||||
pub fn is_ascii_control(&self) -> bool {
|
||||
if *self >= 0x80 { return false; }
|
||||
match ASCII_CHARACTER_CLASS[*self as usize] {
|
||||
C|Cw => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[lang = "u16"]
|
||||
@ -2926,3 +3478,106 @@ impl_from! { u32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0"
|
||||
|
||||
// Float -> Float
|
||||
impl_from! { f32, f64, #[stable(feature = "lossless_float_conv", since = "1.6.0")] }
|
||||
|
||||
static ASCII_LOWERCASE_MAP: [u8; 256] = [
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
||||
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
|
||||
b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
|
||||
b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
|
||||
b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
|
||||
b'@',
|
||||
|
||||
b'a', b'b', b'c', b'd', b'e', b'f', b'g',
|
||||
b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
|
||||
b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
|
||||
b'x', b'y', b'z',
|
||||
|
||||
b'[', b'\\', b']', b'^', b'_',
|
||||
b'`', b'a', b'b', b'c', b'd', b'e', b'f', b'g',
|
||||
b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
|
||||
b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',
|
||||
b'x', b'y', b'z', b'{', b'|', b'}', b'~', 0x7f,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
||||
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
||||
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
||||
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
||||
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
||||
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
||||
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
||||
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
||||
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
|
||||
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
||||
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
||||
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
||||
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
||||
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
||||
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
||||
];
|
||||
|
||||
static ASCII_UPPERCASE_MAP: [u8; 256] = [
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
||||
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||||
b' ', b'!', b'"', b'#', b'$', b'%', b'&', b'\'',
|
||||
b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',
|
||||
b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',
|
||||
b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',
|
||||
b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G',
|
||||
b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
|
||||
b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
|
||||
b'X', b'Y', b'Z', b'[', b'\\', b']', b'^', b'_',
|
||||
b'`',
|
||||
|
||||
b'A', b'B', b'C', b'D', b'E', b'F', b'G',
|
||||
b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',
|
||||
b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',
|
||||
b'X', b'Y', b'Z',
|
||||
|
||||
b'{', b'|', b'}', b'~', 0x7f,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
||||
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
||||
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
||||
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
||||
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
||||
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
||||
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
||||
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
|
||||
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
|
||||
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
|
||||
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
||||
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
||||
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
||||
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
||||
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
||||
];
|
||||
|
||||
enum AsciiCharacterClass {
|
||||
C, // control
|
||||
Cw, // control whitespace
|
||||
W, // whitespace
|
||||
D, // digit
|
||||
L, // lowercase
|
||||
Lx, // lowercase hex digit
|
||||
U, // uppercase
|
||||
Ux, // uppercase hex digit
|
||||
P, // punctuation
|
||||
}
|
||||
use self::AsciiCharacterClass::*;
|
||||
|
||||
static ASCII_CHARACTER_CLASS: [AsciiCharacterClass; 128] = [
|
||||
// _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _a _b _c _d _e _f
|
||||
C, C, C, C, C, C, C, C, C, Cw,Cw,C, Cw,Cw,C, C, // 0_
|
||||
C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, // 1_
|
||||
W, P, P, P, P, P, P, P, P, P, P, P, P, P, P, P, // 2_
|
||||
D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, P, // 3_
|
||||
P, Ux,Ux,Ux,Ux,Ux,Ux,U, U, U, U, U, U, U, U, U, // 4_
|
||||
U, U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, // 5_
|
||||
P, Lx,Lx,Lx,Lx,Lx,Lx,L, L, L, L, L, L, L, L, L, // 6_
|
||||
L, L, L, L, L, L, L, L, L, L, L, P, P, P, P, C, // 7_
|
||||
];
|
||||
|
||||
@ -685,7 +685,7 @@ impl AsciiExt for [u8] {
|
||||
#[inline]
|
||||
fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool {
|
||||
self.len() == other.len() &&
|
||||
self.iter().zip(other).all(|(a, b)| {
|
||||
self.iter().zip(other).all(|(a, &b)| {
|
||||
a.eq_ignore_ascii_case(b)
|
||||
})
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user