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

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

Coerces into an AsciiStr slice.

fn as_str(&self) -> &str

Converts &self to a &str slice.

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

Converts &self into a byte slice.

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

Returns the entire string as slice of AsciiChars.

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

Returns the entire string as mutable slice of AsciiChars.

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.

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.

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

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

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

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

fn chars(&self) -> Chars

Returns an iterator over the characters of the AsciiStr.

fn chars_mut(&mut self) -> CharsMut

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

fn lines(&self) -> Lines

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.

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

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

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

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

Compares two strings case-insensitively.

A replacement for AsciiExt::eq_ignore_ascii_case().

fn make_ascii_uppercase(&mut self)

Replaces lowercase letters with their uppercase equivalent.

A replacement for AsciiExt::make_ascii_uppercase().

fn make_ascii_lowercase(&mut self)

Replaces uppercase letters with their lowercase equivalent.

A replacement for AsciiExt::make_ascii_lowercase().

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.

impl Hash for AsciiStr

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

The method for the indexing (container[index]) operation

impl IndexMut<usize> for AsciiStr

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

The method for 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

The method for the indexing (container[index]) operation

impl IndexMut<Range<usize>> for AsciiStr

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

The method for 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

The method for the indexing (container[index]) operation

impl IndexMut<RangeTo<usize>> for AsciiStr

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

The method for 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

The method for the indexing (container[index]) operation

impl IndexMut<RangeFrom<usize>> for AsciiStr

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

The method for 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

The method for the indexing (container[index]) operation

impl IndexMut<RangeFull> for AsciiStr

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

The method for the mutable indexing (container[index]) operation

impl<'a> IntoIterator for &'a AsciiStr

type Item = &'a AsciiChar

The type of the elements being iterated over.

type IntoIter = Chars<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut AsciiStr

type Item = &'a mut AsciiChar

The type of the elements being iterated over.

type IntoIter = CharsMut<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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.