Struct openssl::x509::SslString
+
+ [−]
+
+ [src]
+pub struct SslString {
+ // some fields omitted
+}Methods from Deref<Target=str>
fn len(&self) -> usize
+Returns the length of self in bytes.
Examples
+assert_eq!("foo".len(), 3); +assert_eq!("ƒoo".len(), 4); // fancy f! ++
fn is_empty(&self) -> bool
+fn width(&self, is_cjk: bool) -> usize
+: use the crates.io unicode-width library instead
Returns a string's displayed width in columns.
+ +Control characters have zero width.
+ +is_cjk determines behavior for characters in the Ambiguous category:
+if is_cjk is
+true, these are 2 columns wide; otherwise, they are 1.
+In CJK locales, is_cjk should be
+true, else it should be false.
+Unicode Standard Annex #11
+recommends that these
+characters be treated as 1 column (i.e., is_cjk = false) if the
+locale is unknown.
fn is_char_boundary(&self, index: usize) -> bool
+: it is unclear whether this method pulls its weight with the existence of the char_indices iterator or this method may want to be replaced with checked slicing
+Checks that index-th byte lies at the start and/or end of a
+UTF-8 code point sequence.
The start and end of the string (when index == self.len()) are
+considered to be
+boundaries.
Panics
+Panics if index is greater than self.len().
Examples
+let s = "Löwe 老虎 Léopard"; +assert!(s.is_char_boundary(0)); +// start of `老` +assert!(s.is_char_boundary(6)); +assert!(s.is_char_boundary(s.len())); + +// second byte of `ö` +assert!(!s.is_char_boundary(2)); + +// third byte of `老` +assert!(!s.is_char_boundary(8)); ++
fn as_bytes(&self) -> &[u8]
+fn as_ptr(&self) -> *const u8
+Returns a raw pointer to the &str's buffer.
The caller must ensure that the string outlives this pointer, and +that it is not +reallocated (e.g. by pushing to the string).
+ +Examples
+let s = "Hello"; +let p = s.as_ptr(); ++
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
+Takes a bytewise slice from a string.
+ +Returns the substring from [begin..end).
Unsafety
+Caller must check both UTF-8 character boundaries and the boundaries +of the entire slice as +well.
+ +Examples
+let s = "Löwe 老虎 Léopard"; + +unsafe { + assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); +} ++
fn slice_chars(&self, begin: usize, end: usize) -> &str
+: may have yet to prove its worth
+Returns a slice of the string from the character range [begin..end).
That is, start at the begin-th code point of the string and continue
+to the end-th code point. This does not detect or handle edge cases
+such as leaving a combining character as the first code point of the
+string.
Due to the design of UTF-8, this operation is O(end). Use slicing
+syntax if you want to use byte indices rather than codepoint indices.
Panics
+Panics if begin > end or the either begin or end are beyond the
+last character of the string.
Examples
+let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.slice_chars(0, 4), "Löwe"); +assert_eq!(s.slice_chars(5, 7), "老虎"); ++
fn char_range_at(&self, start: usize) -> CharRange
+: often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether
+Given a byte position, return the next char and its index.
+ +This can be used to iterate over the Unicode characters of a string.
+ +Panics
+If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 character.
Examples
+This example manually iterates through the characters of a string;
+this should normally be
+done by .chars() or .char_indices().
+use std::str::CharRange; + +let s = "中华Việt Nam"; +let mut i = 0; +while i < s.len() { + let CharRange {ch, next} = s.char_range_at(i); + println!("{}: {}", i, ch); + i = next; +} ++ +
This outputs:
+ +0: 中
+3: 华
+6: V
+7: i
+8: ệ
+11: t
+12:
+13: N
+14: a
+15: m
+fn char_range_at_reverse(&self, start: usize) -> CharRange
+: often replaced by char_indices, this method may be removed in favor of just char_at_reverse() or eventually removed altogether
+Given a byte position, return the previous char and its position.
This function can be used to iterate over a Unicode string in reverse.
+ +Returns 0 for next index if called on start index 0.
+ +Panics
+If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 character.
Examples
+This example manually iterates through the characters of a string;
+this should normally be
+done by .chars().rev() or .char_indices().
+use std::str::CharRange; + +let s = "中华Việt Nam"; +let mut i = s.len(); +while i > 0 { + let CharRange {ch, next} = s.char_range_at_reverse(i); + println!("{}: {}", i, ch); + i = next; +} ++ +
This outputs:
+ +16: m
+15: a
+14: N
+13:
+12: t
+11: ệ
+8: i
+7: V
+6: 华
+3: 中
+fn char_at(&self, i: usize) -> char
+: frequently replaced by the chars() iterator, this method may be removed or possibly renamed in the future; it is normally replaced by chars/char_indices iterators or by getting the first char from a subslice
+Given a byte position, return the char at that position.
Panics
+If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 character.
Examples
+let s = "abπc"; +assert_eq!(s.char_at(1), 'b'); +assert_eq!(s.char_at(2), 'π'); ++
fn char_at_reverse(&self, i: usize) -> char
+: see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics
+Given a byte position, return the char at that position, counting
+from the end.
Panics
+If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 character.
Examples
+let s = "abπc"; +assert_eq!(s.char_at_reverse(1), 'a'); +assert_eq!(s.char_at_reverse(2), 'b'); ++
fn slice_shift_char(&self) -> Option<(char, &str)>
+: awaiting conventions about shifting and slices and may not be warranted with the existence of the chars and/or char_indices iterators
+Retrieves the first character from a &str and returns it.
This does not allocate a new string; instead, it returns a slice that +points one character +beyond the character that was shifted.
+ +If the slice does not contain any characters, None is returned instead.
+ +Examples
+let s = "Löwe 老虎 Léopard"; +let (c, s1) = s.slice_shift_char().unwrap(); + +assert_eq!(c, 'L'); +assert_eq!(s1, "öwe 老虎 Léopard"); + +let (c, s2) = s1.slice_shift_char().unwrap(); + +assert_eq!(c, 'ö'); +assert_eq!(s2, "we 老虎 Léopard"); ++
fn split_at(&self, mid: usize) -> (&str, &str)
+: library is unlikely to be stabilized with the current layout and name, use std::collections instead
+Divide one string slice into two at an index.
+ +The index mid is a byte offset from the start of the string
+that must be on a character boundary.
Return slices &self[..mid] and &self[mid..].
Panics
+Panics if mid is beyond the last character of the string,
+or if it is not on a character boundary.
Examples
+let s = "Löwe 老虎 Léopard"; +let first_space = s.find(' ').unwrap_or(s.len()); +let (a, b) = s.split_at(first_space); + +assert_eq!(a, "Löwe"); +assert_eq!(b, " 老虎 Léopard"); ++
fn chars(&self) -> Chars
+An iterator over the codepoints of self.
Examples
+let v: Vec<char> = "abc åäö".chars().collect(); + +assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); ++
fn char_indices(&self) -> CharIndices
+An iterator over the characters of self and their byte offsets.
Examples
+let v: Vec<(usize, char)> = "abc".char_indices().collect(); +let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; + +assert_eq!(v, b); ++
fn bytes(&self) -> Bytes
+An iterator over the bytes of self.
Examples
+let v: Vec<u8> = "bors".bytes().collect(); + +assert_eq!(v, b"bors".to_vec()); ++
fn split_whitespace(&self) -> SplitWhitespace
+An iterator over the non-empty substrings of self which contain no whitespace,
+and which are separated by any amount of whitespace.
Examples
+let some_words = " Mary had\ta little \n\t lamb"; +let v: Vec<&str> = some_words.split_whitespace().collect(); + +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); ++
fn words(&self) -> SplitWhitespace
+: words() will be removed. Use split_whitespace() instead
+An iterator over the non-empty substrings of self which contain no whitespace,
+and which are separated by any amount of whitespace.
Examples
+let some_words = " Mary had\ta little \n\t lamb"; +let v: Vec<&str> = some_words.words().collect(); + +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); ++
fn lines(&self) -> Lines
+An iterator over the lines of a string, separated by \n.
This does not include the empty string after a trailing \n.
Examples
+let four_lines = "foo\nbar\n\nbaz"; +let v: Vec<&str> = four_lines.lines().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++ +
Leaving off the trailing character:
++let four_lines = "foo\nbar\n\nbaz\n"; +let v: Vec<&str> = four_lines.lines().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++
fn lines_any(&self) -> LinesAny
+An iterator over the lines of a string, separated by either
+\n or \r\n.
As with .lines(), this does not include an empty trailing line.
Examples
+let four_lines = "foo\r\nbar\n\r\nbaz"; +let v: Vec<&str> = four_lines.lines_any().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++ +
Leaving off the trailing character:
++let four_lines = "foo\r\nbar\n\r\nbaz\n"; +let v: Vec<&str> = four_lines.lines_any().collect(); + +assert_eq!(v, ["foo", "bar", "", "baz"]); ++
fn nfd_chars(&self) -> Decompositions
+: use the crates.io unicode-normalization library instead
Returns an iterator over the string in Unicode Normalization Form D +(canonical decomposition).
+fn nfkd_chars(&self) -> Decompositions
+: use the crates.io unicode-normalization library instead
Returns an iterator over the string in Unicode Normalization Form KD +(compatibility decomposition).
+fn nfc_chars(&self) -> Recompositions
+: use the crates.io unicode-normalization library instead
An Iterator over the string in Unicode Normalization Form C +(canonical decomposition followed by canonical composition).
+fn nfkc_chars(&self) -> Recompositions
+: use the crates.io unicode-normalization library instead
An Iterator over the string in Unicode Normalization Form KC +(compatibility decomposition followed by canonical composition).
+fn graphemes(&self, is_extended: bool) -> Graphemes
+: use the crates.io unicode-segmentation library instead
Returns an iterator over the grapheme clusters of self.
If is_extended is true, the iterator is over the
+extended grapheme clusters;
+otherwise, the iterator is over the legacy grapheme clusters.
+UAX#29
+recommends extended grapheme cluster boundaries for general processing.
Examples
+let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); +let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; + +assert_eq!(&gr1[..], b); + +let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); +let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; + +assert_eq!(&gr2[..], b); ++
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices
+: use the crates.io unicode-segmentation library instead
Returns an iterator over the grapheme clusters of self and their
+byte offsets. See
+graphemes() for more information.
Examples
+let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); +let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; + +assert_eq!(&gr_inds[..], b); ++
fn utf16_units(&self) -> Utf16Units
+: this functionality may only be provided by libunicode
+Returns an iterator of u16 over the string encoded as UTF-16.
fn contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
+Returns true if self contains another &str.
Examples
+assert!("bananas".contains("nana")); + +assert!(!"bananas".contains("foobar")); ++
fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
+Returns true if the given &str is a prefix of the string.
Examples
+assert!("banana".starts_with("ba")); ++
fn ends_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+Returns true if the given &str is a suffix of the string.
Examples
+assert!("banana".ends_with("nana")); ++
fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>
+Returns the byte index of the first character of self that matches
+the pattern, if it
+exists.
Returns None if it doesn't exist.
The pattern can be a simple &str, char, or a closure that
+determines the
+split.
Examples
+Simple patterns:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.find('L'), Some(0)); +assert_eq!(s.find('é'), Some(14)); +assert_eq!(s.find("Léopard"), Some(13)); ++ +
More complex patterns with closures:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.find(char::is_whitespace), Some(5)); +assert_eq!(s.find(char::is_lowercase), Some(1)); ++ +
Not finding the pattern:
++let s = "Löwe 老虎 Léopard"; +let x: &[_] = &['1', '2']; + +assert_eq!(s.find(x), None); ++
fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+Returns the byte index of the last character of self that
+matches the pattern, if it
+exists.
Returns None if it doesn't exist.
The pattern can be a simple &str, char,
+or a closure that determines the split.
Examples
+Simple patterns:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.rfind('L'), Some(13)); +assert_eq!(s.rfind('é'), Some(14)); ++ +
More complex patterns with closures:
++let s = "Löwe 老虎 Léopard"; + +assert_eq!(s.rfind(char::is_whitespace), Some(12)); +assert_eq!(s.rfind(char::is_lowercase), Some(20)); ++ +
Not finding the pattern:
++let s = "Löwe 老虎 Léopard"; +let x: &[_] = &['1', '2']; + +assert_eq!(s.rfind(x), None); ++
fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>
+An iterator over substrings of self, separated by characters
+matched by a pattern.
The pattern can be a simple &str, char, or a closure that
+determines the split. Additional libraries might provide more complex
+patterns like regular expressions.
Iterator behavior
+The returned iterator will be double ended if the pattern allows a
+reverse search and forward/reverse search yields the same elements.
+This is true for, eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rsplit() can be used.
Examples
+Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); +assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); + +let v: Vec<&str> = "".split('X').collect(); +assert_eq!(v, [""]); + +let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); +assert_eq!(v, ["lion", "", "tiger", "leopard"]); + +let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); +assert_eq!(v, ["lion", "tiger", "leopard"]); + +let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect(); +assert_eq!(v, ["abc", "def", "ghi"]); + +let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); +assert_eq!(v, ["lion", "tiger", "leopard"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["abc", "def", "ghi"]); ++ +
If a string contains multiple contiguous separators, you will end up +with empty strings in the output:
++let x = "||||a||b|c".to_string(); +let d: Vec<_> = x.split('|').collect(); + +assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); ++ +
This can lead to possibly surprising behavior when whitespace is used +as the separator. This code is correct:
++let x = " a b c".to_string(); +let d: Vec<_> = x.split(' ').collect(); + +assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); ++ +
It does not give you:
++assert_eq!(d, &["a", "b", "c"]); ++
fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+An iterator over substrings of self, separated by characters
+matched by a pattern and yielded in reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, split() can be used.
Examples
+Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); +assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); + +let v: Vec<&str> = "".rsplit('X').collect(); +assert_eq!(v, [""]); + +let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); +assert_eq!(v, ["leopard", "tiger", "", "lion"]); + +let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); +assert_eq!(v, ["leopard", "tiger", "lion"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["ghi", "def", "abc"]); ++
fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>
+An iterator over substrings of self, separated by characters
+matched by a pattern.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns
+like regular expressions.
Equivalent to split, except that the trailing substring
+is skipped if empty.
This method can be used for string data that is terminated, +rather than separated by a pattern.
+ +Iterator behavior
+The returned iterator will be double ended if the pattern allows a
+reverse search
+and forward/reverse search yields the same elements. This is true
+for, eg, char but not for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rsplit_terminator() can be used.
Examples
+let v: Vec<&str> = "A.B.".split_terminator('.').collect(); +assert_eq!(v, ["A", "B"]); + +let v: Vec<&str> = "A..B..".split_terminator(".").collect(); +assert_eq!(v, ["A", "", "B", ""]); ++
fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+An iterator over substrings of self, separated by characters
+matched by a pattern and yielded in reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Equivalent to split, except that the trailing substring is
+skipped if empty.
This method can be used for string data that is terminated, +rather than separated by a pattern.
+ +Iterator behavior
+The returned iterator requires that the pattern supports a +reverse search, and it will be double ended if a forward/reverse +search yields the same elements.
+ +For iterating from the front, split_terminator() can be used.
Examples
+let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); +assert_eq!(v, ["B", "A"]); + +let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); +assert_eq!(v, ["", "B", "", "A"]); ++
fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>
+An iterator over substrings of self, separated by a pattern,
+restricted to returning
+at most count items.
The last element returned, if any, will contain the remainder of the
+string.
+The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator will not be double ended, because it is +not efficient to support.
+ +If the pattern allows a reverse search, rsplitn() can be used.
Examples
+Simple patterns:
++let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); +assert_eq!(v, ["Mary", "had", "a little lambda"]); + +let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); +assert_eq!(v, ["lion", "", "tigerXleopard"]); + +let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); +assert_eq!(v, ["abcXdef"]); + +let v: Vec<&str> = "".splitn(1, 'X').collect(); +assert_eq!(v, [""]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["abc", "defXghi"]); ++
fn rsplitn<'a, P>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+An iterator over substrings of self, separated by a pattern,
+starting from the end of the string, restricted to returning
+at most count items.
The last element returned, if any, will contain the remainder of the +string.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator will not be double ended, because it is not +efficient to support.
+ +splitn() can be used for splitting from the front.
Examples
+Simple patterns:
++let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); +assert_eq!(v, ["lamb", "little", "Mary had a"]); + +let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); +assert_eq!(v, ["leopard", "tiger", "lionX"]); + +let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); +assert_eq!(v, ["leopard", "lion::tiger"]); ++ +
A more complex pattern, using a closure:
++let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect(); +assert_eq!(v, ["ghi", "abc1def"]); ++
fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>
+An iterator over the matches of a pattern within self.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator will be double ended if the pattern allows
+a reverse search
+and forward/reverse search yields the same elements. This is true
+for, eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rmatches() can be used.
Examples
+let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); +assert_eq!(v, ["abc", "abc", "abc"]); + +let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect(); +assert_eq!(v, ["1", "2", "3"]); ++
fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+An iterator over the matches of a pattern within self, yielded in
+reverse order.
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, matches() can be used.
Examples
+let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); +assert_eq!(v, ["abc", "abc", "abc"]); + +let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect(); +assert_eq!(v, ["3", "2", "1"]); ++
fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>
+: might have its iterator type changed
+An iterator over the start and end indices of the disjoint matches
+of a pattern within self.
For matches of pat within self that overlap, only the indices
+corresponding to the first
+match are returned.
The pattern can be a simple &str, char, or a closure that
+determines
+the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator will be double ended if the pattern allows a
+reverse search
+and forward/reverse search yields the same elements. This is true for,
+eg, char but not
+for &str.
If the pattern allows a reverse search but its results might differ
+from a forward search, rmatch_indices() can be used.
Examples
+let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); +assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); + +let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); +assert_eq!(v, [(1, 4), (4, 7)]); + +let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); +assert_eq!(v, [(0, 3)]); // only the first `aba` ++
fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+: might have its iterator type changed
+An iterator over the start and end indices of the disjoint matches of
+a pattern within
+self, yielded in reverse order.
For matches of pat within self that overlap, only the indices
+corresponding to the last
+match are returned.
The pattern can be a simple &str, char, or a closure that
+determines
+the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
Iterator behavior
+The returned iterator requires that the pattern supports a +reverse search, +and it will be double ended if a forward/reverse search yields +the same elements.
+ +For iterating from the front, match_indices() can be used.
Examples
+let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); +assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); + +let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); +assert_eq!(v, [(4, 7), (1, 4)]); + +let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); +assert_eq!(v, [(2, 5)]); // only the last `aba` ++
fn subslice_offset(&self, inner: &str) -> usize
+: awaiting convention about comparability of arbitrary slices
+Returns the byte offset of an inner slice relative to an enclosing +outer slice.
+ +Panics
+Panics if inner is not a direct slice contained within self.
Examples
+let string = "a\nb\nc"; +let lines: Vec<&str> = string.lines().collect(); + +assert!(string.subslice_offset(lines[0]) == 0); // &"a" +assert!(string.subslice_offset(lines[1]) == 2); // &"b" +assert!(string.subslice_offset(lines[2]) == 4); // &"c" ++
fn trim(&self) -> &str
+Returns a &str with leading and trailing whitespace removed.
Examples
+let s = " Hello\tworld\t"; +assert_eq!(s.trim(), "Hello\tworld"); ++
fn trim_left(&self) -> &str
+Returns a &str with leading whitespace removed.
Examples
+let s = " Hello\tworld\t"; +assert_eq!(s.trim_left(), "Hello\tworld\t"); ++
fn trim_right(&self) -> &str
+Returns a &str with trailing whitespace removed.
Examples
+let s = " Hello\tworld\t"; +assert_eq!(s.trim_right(), " Hello\tworld"); ++
fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: DoubleEndedSearcher<'a>
+Returns a string with all pre- and suffixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple char, or a closure that determines
+the split.
Examples
+Simple patterns:
++assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); +assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); ++ +
A more complex pattern, using a closure:
++assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar"); ++
fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>
+Returns a string with all prefixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
Examples
+assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); +assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); ++
fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
+Returns a string with all suffixes that match a pattern +repeatedly removed.
+ +The pattern can be a simple &str, char, or a closure that
+determines the split.
Examples
+Simple patterns:
++assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); +assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar"); + +let x: &[_] = &['1', '2']; +assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); ++ +
A more complex pattern, using a closure:
++assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX"); ++
fn parse<F>(&self) -> Result<F, F::Err> where F: FromStr
+Parses self into the specified type.
Failure
+Will return Err if it's not possible to parse self into the type.
Example
+assert_eq!("4".parse::<u32>(), Ok(4)); ++ +
Failing:
++assert!("j".parse::<u32>().is_err()); ++
fn replace(&self, from: &str, to: &str) -> String
+Replaces all occurrences of one string with another.
+ +replace takes two arguments, a sub-&str to find in self, and a
+second &str to
+replace it with. If the original &str isn't found, no change occurs.
Examples
+let s = "this is old"; + +assert_eq!(s.replace("old", "new"), "this is new"); ++ +
When a &str isn't found:
+let s = "this is old"; +assert_eq!(s.replace("cookie monster", "little lamb"), s); ++
fn to_lowercase(&self) -> String
+Returns the lowercase equivalent of this string.
+ +Examples
+#![feature(str_casing)] + +let s = "HELLO"; +assert_eq!(s.to_lowercase(), "hello"); ++
fn to_uppercase(&self) -> String
+Returns the uppercase equivalent of this string.
+ +Examples
+#![feature(str_casing)] + +let s = "hello"; +assert_eq!(s.to_uppercase(), "HELLO"); ++
fn escape_default(&self) -> String
+: return type may change to be an iterator
+Escapes each char in s with char::escape_default.
fn escape_unicode(&self) -> String
+: return type may change to be an iterator
+Escapes each char in s with char::escape_unicode.