Struct kiss_ui::widget::WidgetStr
[−]
[src]
pub struct WidgetStr<'a> {
// some fields omitted
}A string slice borrowed from a widget's metadata. Can be dereferenced to &str.
Tracks ownership of the string so that its pointer cannot be invalidated. Releases ownership on-drop.
Methods
impl<'a> WidgetStr<'a>
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.