[−][src]Struct ascii::AsciiStr

#[repr(transparent)]
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`[src]

`pub fn as_str(&self) -> &str`[src]

Converts &self to a &str slice.

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

Converts &self into a byte slice.

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

Returns the entire string as slice of AsciiChars.

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

Returns the entire string as mutable slice of AsciiChars.

`pub const fn as_ptr(&self) -> *const AsciiChar`[src]

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`[src]

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 from_ascii<B: ?Sized>(bytes: &B) -> Result<&AsciiStr, AsAsciiStrError> where B: AsRef<[u8]>,` [src]

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

Examples

let foo = AsciiStr::from_ascii(b"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(bytes: &[u8]) -> &AsciiStr`[src]

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(&b"foo"[..]) };
assert_eq!(foo.as_str(), "foo");

`pub fn len(&self) -> usize`[src]

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`[src]

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

ⓘImportant traits for Chars<'a>
Important traits for Chars<'a>
`impl<'a> Iterator for Chars<'a> type Item = AsciiChar;`
`pub fn chars(&self) -> Chars`[src]

Returns an iterator over the characters of the AsciiStr.

ⓘImportant traits for CharsMut<'a>
Important traits for CharsMut<'a>
`impl<'a> Iterator for CharsMut<'a> type Item = &'a mut AsciiChar;`
`pub fn chars_mut(&mut self) -> CharsMut`[src]

Returns an iterator over the characters of the AsciiStr which allows you to modify the value of each AsciiChar.

`pub fn split(&self, on: AsciiChar) -> impl DoubleEndedIterator<Item = &AsciiStr>`[src]

Returns an iterator over parts of the AsciiStr separated by a character.

Examples

let words = AsciiStr::from_ascii("apple banana lemon").unwrap()
    .split(AsciiChar::Space)
    .map(|a| a.as_str())
    .collect::<Vec<_>>();
assert_eq!(words, ["apple", "banana", "lemon"]);

`pub fn lines(&self) -> impl DoubleEndedIterator<Item = &AsciiStr>`[src]

Returns an iterator over the lines of the AsciiStr, which are themselves AsciiStrs.

Lines are ended with either LineFeed (\n), or CarriageReturn then LineFeed (\r\n).

The final line ending is optional.

`pub fn trim(&self) -> &Self`[src]

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_start(&self) -> &Self`[src]

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

`pub fn trim_end(&self) -> &Self`[src]

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

`pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool`[src]

Compares two strings case-insensitively.

`pub fn make_ascii_uppercase(&mut self)`[src]

Replaces lowercase letters with their uppercase equivalent.

`pub fn make_ascii_lowercase(&mut self)`[src]

Replaces uppercase letters with their lowercase equivalent.

`pub fn first(&self) -> Option<AsciiChar>`[src]

Returns the first character if the string is not empty.

`pub fn last(&self) -> Option<AsciiChar>`[src]

Returns the last character if the string is not empty.

Trait Implementations

`impl AsAsciiStr for AsciiStr`[src]

`type Inner = AsciiChar`

`fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError> where R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,` [src]

`fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError>`[src]

`unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr`[src]

`fn get_ascii(&self, index: usize) -> Option<AsciiChar>`[src]

`impl AsMutAsciiStr for AsciiStr`[src]

`fn slice_ascii_mut<R>( &mut self, range: R ) -> Result<&mut AsciiStr, AsAsciiStrError> where R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,` [src]

`unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr`[src]

`fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError>`[src]

Convert to a mutable ASCII slice.

`impl PartialEq<AsciiStr> for AsciiStr`[src]

`fn eq(&self, other: &AsciiStr) -> bool`[src]

`fn ne(&self, other: &AsciiStr) -> bool`[src]

`impl PartialEq<str> for AsciiStr`[src]

`fn eq(&self, other: &str) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl PartialEq<AsciiStr> for str`[src]

`fn eq(&self, other: &AsciiStr) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl PartialEq<[u8]> for AsciiStr`[src]

`fn eq(&self, other: &[u8]) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl PartialEq<AsciiStr> for [u8]`[src]

`fn eq(&self, other: &AsciiStr) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl PartialEq<[AsciiChar]> for AsciiStr`[src]

`fn eq(&self, other: &[AsciiChar]) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl PartialEq<AsciiStr> for [AsciiChar]`[src]

`fn eq(&self, other: &AsciiStr) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl Eq for AsciiStr`[src]

`impl Ord for AsciiStr`[src]

`fn cmp(&self, other: &AsciiStr) -> Ordering`[src]

`fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

`fn clamp(self, min: Self, max: Self) -> Self`[src]

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

Restrict a value to a certain interval. Read more

`impl PartialOrd<AsciiStr> for AsciiStr`[src]

`fn partial_cmp(&self, other: &AsciiStr) -> Option<Ordering>`[src]

`fn lt(&self, other: &AsciiStr) -> bool`[src]

`fn le(&self, other: &AsciiStr) -> bool`[src]

`fn gt(&self, other: &AsciiStr) -> bool`[src]

`fn ge(&self, other: &AsciiStr) -> bool`[src]

`impl Hash for AsciiStr`[src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

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

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

`impl Display for AsciiStr`[src]

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