Struct ascii::AsciiStr

pub struct AsciiStr { /* fields omitted */ }

AsciiStr represents a byte or string slice that only contains ASCII characters.

It wraps an [AsciiChar] and implements many of strs methods and traits.

It can be created by a checked conversion from a str or [u8], or borrowed from an AsciiString.

Methods

impl AsciiStr

pub fn new<S: AsRef<AsciiStr> + ?Sized>(s: &S) -> &AsciiStr

Coerces into an AsciiStr slice.

pub fn as_str(&self) -> &str

Converts &self to a &str slice.

pub fn as_bytes(&self) -> &[u8]

Converts &self into a byte slice.

pub fn as_slice(&self) -> &[AsciiChar]

Returns the entire string as slice of AsciiChars.

pub fn as_mut_slice(&mut self) -> &mut [AsciiChar]

Returns the entire string as mutable slice of AsciiChars.

pub fn as_ptr(&self) -> *const AsciiChar

Returns a raw pointer to the AsciiStr's buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the AsciiStr may cause it's buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_mut_ptr(&mut self) -> *mut AsciiChar

Returns an unsafe mutable pointer to the AsciiStr's buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the AsciiStr may cause it's buffer to be reallocated, which would also make any pointers to it invalid.

pub fn to_ascii_string(&self) -> AsciiString

Copies the content of this AsciiStr into an owned AsciiString.

pub fn from_ascii<B: ?Sized>(bytes: &B) -> Result<&AsciiStr, AsAsciiStrError> where
    B: AsRef<[u8]>, 

Converts anything that can represent a byte slice into an AsciiStr.

Examples

let foo = AsciiStr::from_ascii("foo");
let err = AsciiStr::from_ascii("Ŋ");
assert_eq!(foo.unwrap().as_str(), "foo");
assert_eq!(err.unwrap_err().valid_up_to(), 0);

pub unsafe fn from_ascii_unchecked<B: ?Sized>(bytes: &B) -> &AsciiStr where
    B: AsRef<[u8]>, 

Converts anything that can be represented as a byte slice to an AsciiStr without checking for non-ASCII characters..

Examples

let foo = unsafe{ AsciiStr::from_ascii_unchecked("foo") };
assert_eq!(foo.as_str(), "foo");

pub fn len(&self) -> usize

Returns the number of characters / bytes in this ASCII sequence.

Examples

let s = AsciiStr::from_ascii("foo").unwrap();
assert_eq!(s.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the ASCII slice contains zero bytes.

Examples

let mut empty = AsciiStr::from_ascii("").unwrap();
let mut full = AsciiStr::from_ascii("foo").unwrap();
assert!(empty.is_empty());
assert!(!full.is_empty());

pub fn trim(&self) -> &Self

Returns an ASCII string slice with leading and trailing whitespace removed.

Examples

let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
assert_eq!("white \tspace", example.trim());

pub fn trim_left(&self) -> &Self

Returns an ASCII string slice with leading whitespace removed.

Examples

let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
assert_eq!("white \tspace  \t", example.trim_left());

pub fn trim_right(&self) -> &Self

Returns an ASCII string slice with trailing whitespace removed.

Examples

let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
assert_eq!("  \twhite \tspace", example.trim_right());

Trait Implementations

impl PartialEq for AsciiStr

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

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

fn ne(&self, __arg_0: &AsciiStr) -> bool

This method tests for !=.

impl Eq for AsciiStr

impl PartialOrd for AsciiStr

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

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

fn lt(&self, __arg_0: &AsciiStr) -> bool

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

fn le(&self, __arg_0: &AsciiStr) -> bool

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

fn gt(&self, __arg_0: &AsciiStr) -> bool

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

fn ge(&self, __arg_0: &AsciiStr) -> bool

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

impl Ord for AsciiStr

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl Hash for AsciiStr

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

Feeds this value into the given [Hasher].

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

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

impl PartialEq<str> for AsciiStr

fn eq(&self, other: &str) -> 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 PartialEq<AsciiStr> for str

fn eq(&self, other: &AsciiStr) -> 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 ToOwned for AsciiStr

type Owned = AsciiString

fn to_owned(&self) -> AsciiString

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning.

impl AsRef<[u8]> for AsciiStr

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl AsRef<str> for AsciiStr

fn as_ref(&self) -> &str

Performs the conversion.

impl AsRef<[AsciiChar]> for AsciiStr

fn as_ref(&self) -> &[AsciiChar]

Performs the conversion.

impl AsMut<[AsciiChar]> for AsciiStr

fn as_mut(&mut self) -> &mut [AsciiChar]

Performs the conversion.

impl Default for &'static AsciiStr

fn default() -> &'static AsciiStr

Returns the "default value" for a type.

impl<'a> From<&'a [AsciiChar]> for &'a AsciiStr

fn from(slice: &[AsciiChar]) -> &AsciiStr

Performs the conversion.

impl<'a> From<&'a mut [AsciiChar]> for &'a mut AsciiStr

fn from(slice: &mut [AsciiChar]) -> &mut AsciiStr

Performs the conversion.

impl<'a> From<&'a AsciiStr> for &'a [AsciiChar]

fn from(slice: &AsciiStr) -> &[AsciiChar]

Performs the conversion.

impl<'a> From<&'a mut AsciiStr> for &'a mut [AsciiChar]

fn from(slice: &mut AsciiStr) -> &mut [AsciiChar]

Performs the conversion.

impl<'a> From<&'a AsciiStr> for &'a [u8]

fn from(slice: &AsciiStr) -> &[u8]

Performs the conversion.

impl<'a> From<&'a mut AsciiStr> for &'a mut [u8]

fn from(slice: &mut AsciiStr) -> &mut [u8]

Performs the conversion.

impl<'a> From<&'a AsciiStr> for &'a str

fn from(slice: &AsciiStr) -> &str

Performs the conversion.

impl<'a> From<&'a mut AsciiStr> for &'a mut str

fn from(slice: &mut AsciiStr) -> &mut str

Performs the conversion.

impl Display for AsciiStr

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

Formats the value using the given formatter.

impl Debug for AsciiStr

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

Formats the value using the given formatter.

impl Index<usize> for AsciiStr

type Output = AsciiChar

The returned type after indexing.

fn index(&self, index: usize) -> &AsciiChar

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for AsciiStr

fn index_mut(&mut self, index: usize) -> &mut AsciiChar

Performs the mutable indexing (container[index]) operation.

impl Index<Range<usize>> for AsciiStr

type Output = AsciiStr

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &AsciiStr

Performs the indexing (container[index]) operation.

impl IndexMut<Range<usize>> for AsciiStr

fn index_mut(&mut self, index: Range<usize>) -> &mut AsciiStr

Performs the mutable indexing (container[index]) operation.

impl Index<RangeTo<usize>> for AsciiStr

type Output = AsciiStr

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &AsciiStr

Performs the indexing (container[index]) operation.

impl IndexMut<RangeTo<usize>> for AsciiStr

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut AsciiStr

Performs the mutable indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for AsciiStr

type Output = AsciiStr

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &AsciiStr

Performs the indexing (container[index]) operation.

impl IndexMut<RangeFrom<usize>> for AsciiStr

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut AsciiStr

Performs the mutable indexing (container[index]) operation.

impl Index<RangeFull> for AsciiStr

type Output = AsciiStr

The returned type after indexing.

fn index(&self, index: RangeFull) -> &AsciiStr

Performs the indexing (container[index]) operation.

impl IndexMut<RangeFull> for AsciiStr

fn index_mut(&mut self, index: RangeFull) -> &mut AsciiStr

Performs the mutable indexing (container[index]) operation.

impl AsciiExt for AsciiStr

type Owned = AsciiString

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

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

fn to_ascii_lowercase(&self) -> AsciiString

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

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

Checks that two values 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.

fn is_ascii_alphabetic(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII alphabetic character: U+0041 'A' ... U+005A 'Z' or U+0061 'a' ... U+007A 'z'. For strings, true if all characters in the string are ASCII alphabetic.

fn is_ascii_uppercase(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII uppercase character: U+0041 'A' ... U+005A 'Z'. For strings, true if all characters in the string are ASCII uppercase.

fn is_ascii_lowercase(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII lowercase character: U+0061 'a' ... U+007A 'z'. For strings, true if all characters in the string are ASCII lowercase.

fn is_ascii_alphanumeric(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

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'. For strings, true if all characters in the string are ASCII alphanumeric.

fn is_ascii_digit(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII decimal digit: U+0030 '0' ... U+0039 '9'. For strings, true if all characters in the string are ASCII digits.

fn is_ascii_hexdigit(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

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'. For strings, true if all characters in the string are ASCII hex digits.

fn is_ascii_punctuation(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII punctuation character:

fn is_ascii_graphic(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

Checks if the value is an ASCII graphic character: U+0021 '@' ... U+007E '~'. For strings, true if all characters in the string are ASCII graphic characters.

fn is_ascii_whitespace(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

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. For strings, true if all characters in the string are ASCII whitespace.

fn is_ascii_control(&self) -> bool

🔬 This is a nightly-only experimental API. (ascii_ctype)

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.

impl AsAsciiStr for AsciiStr

fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError>

Convert to an ASCII slice.

unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr

Convert to an ASCII slice without checking for non-ASCII characters.

impl AsMutAsciiStr for AsciiStr

fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError>

Convert to a mutable ASCII slice.

unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr

Convert to a mutable ASCII slice without checking for non-ASCII characters.

impl<'a> PartialEq<String> for &'a AsciiStr

fn eq(&self, other: &String) -> bool

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

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

This method tests for !=.

impl<'a> PartialEq<&'a AsciiStr> for String

fn eq(&self, other: &&'a AsciiStr) -> bool

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

fn ne(&self, other: &&'a AsciiStr) -> bool

This method tests for !=.

impl<'a> PartialEq<AsciiString> for &'a AsciiStr

fn eq(&self, other: &AsciiString) -> bool

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

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

This method tests for !=.

impl<'a> PartialEq<&'a AsciiStr> for AsciiString

fn eq(&self, other: &&'a AsciiStr) -> bool

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

fn ne(&self, other: &&'a AsciiStr) -> bool

This method tests for !=.

impl Borrow<AsciiStr> for AsciiString

fn borrow(&self) -> &AsciiStr

Immutably borrows from an owned value.

impl AsRef<AsciiStr> for AsciiString

fn as_ref(&self) -> &AsciiStr

Performs the conversion.

impl AsMut<AsciiStr> for AsciiString

fn as_mut(&mut self) -> &mut AsciiStr

Performs the conversion.

impl<'a> FromIterator<&'a AsciiStr> for AsciiString

fn from_iter<I: IntoIterator<Item = &'a AsciiStr>>(iter: I) -> AsciiString

Creates a value from an iterator.

impl<'a> Extend<&'a AsciiStr> for AsciiString

fn extend<I: IntoIterator<Item = &'a AsciiStr>>(&mut self, iterable: I)

Extends a collection with the contents of an iterator.

impl<'a> Add<&'a AsciiStr> for AsciiString

type Output = AsciiString

The resulting type after applying the + operator.

fn add(self, other: &AsciiStr) -> AsciiString

Performs the + operation.