diff --git a/frontend/struct.FILES.html b/frontend/struct.FILES.html index 17f4090a..d14779bf 100644 --- a/frontend/struct.FILES.html +++ b/frontend/struct.FILES.html @@ -1,10 +1,10 @@ frontend::FILES - Rust -

Function guard::get_identity_service[][src]

pub fn get_identity_service() -> IdentityService<CookieIdentityPolicy>
\ No newline at end of file diff --git a/guard/fn.get_json_err.html b/guard/fn.get_json_err.html index dbdbed06..587b8621 100644 --- a/guard/fn.get_json_err.html +++ b/guard/fn.get_json_err.html @@ -1,5 +1,5 @@ guard::get_json_err - Rust

Function guard::get_json_err[][src]

pub fn get_json_err() -> JsonConfig
+ Change settings

Function guard::get_json_err[][src]

pub fn get_json_err() -> JsonConfig
\ No newline at end of file diff --git a/guard/fn.main.html b/guard/fn.main.html index a43dac8d..a2ba8e4c 100644 --- a/guard/fn.main.html +++ b/guard/fn.main.html @@ -1,5 +1,5 @@ guard::main - Rust

Function guard::main[][src]

pub(crate) fn main() -> Result<()>
+ Change settings

Function guard::main[][src]

pub(crate) fn main() -> Result<()>
\ No newline at end of file diff --git a/guard/index.html b/guard/index.html index 6765f069..c4f0d151 100644 --- a/guard/index.html +++ b/guard/index.html @@ -1,9 +1,9 @@ guard - Rust

Crate guard[][src]

Modules

-
api
data
docs
errors
settings

Structs

-
Data
S
SETTINGS
Settings

Statics

+ Change settings

Crate guard[][src]

Modules

+
api
data
docs
errors
settings
templates

Structs

+
CSS
Data
FILES
JS
S
SETTINGS
Settings

Statics

GIT_COMMIT_HASH
OPEN_API_DOC
PKG_DESCRIPTION
PKG_HOMEPAGE
PKG_NAME
VERIFICATION_PATH
VERSION

Functions

get_identity_service
get_json_err
main
\ No newline at end of file diff --git a/guard/sidebar-items.js b/guard/sidebar-items.js index 855e75b9..2ac94614 100644 --- a/guard/sidebar-items.js +++ b/guard/sidebar-items.js @@ -1 +1 @@ -initSidebarItems({"fn":[["get_identity_service",""],["get_json_err",""],["main",""]],"mod":[["api",""],["data",""],["docs",""],["errors",""],["settings",""]],"static":[["GIT_COMMIT_HASH",""],["OPEN_API_DOC",""],["PKG_DESCRIPTION",""],["PKG_HOMEPAGE",""],["PKG_NAME",""],["VERIFICATION_PATH",""],["VERSION",""]],"struct":[["Data",""],["S",""],["SETTINGS",""],["Settings",""]]}); \ No newline at end of file +initSidebarItems({"fn":[["get_identity_service",""],["get_json_err",""],["main",""]],"mod":[["api",""],["data",""],["docs",""],["errors",""],["settings",""],["templates",""]],"static":[["GIT_COMMIT_HASH",""],["OPEN_API_DOC",""],["PKG_DESCRIPTION",""],["PKG_HOMEPAGE",""],["PKG_NAME",""],["VERIFICATION_PATH",""],["VERSION",""]],"struct":[["CSS",""],["Data",""],["FILES",""],["JS",""],["S",""],["SETTINGS",""],["Settings",""]]}); \ No newline at end of file diff --git a/guard/static.GIT_COMMIT_HASH.html b/guard/static.GIT_COMMIT_HASH.html index 4e4f0fd8..db398110 100644 --- a/guard/static.GIT_COMMIT_HASH.html +++ b/guard/static.GIT_COMMIT_HASH.html @@ -1,5 +1,5 @@ guard::GIT_COMMIT_HASH - Rust

Static guard::GIT_COMMIT_HASH[][src]

pub static GIT_COMMIT_HASH: &str
+ Change settings

Static guard::GIT_COMMIT_HASH[][src]

pub static GIT_COMMIT_HASH: &str
\ No newline at end of file diff --git a/guard/static.OPEN_API_DOC.html b/guard/static.OPEN_API_DOC.html index ef12d7fd..a2054479 100644 --- a/guard/static.OPEN_API_DOC.html +++ b/guard/static.OPEN_API_DOC.html @@ -1,5 +1,5 @@ guard::OPEN_API_DOC - Rust

Static guard::OPEN_API_DOC[][src]

pub static OPEN_API_DOC: &str
+ Change settings

Static guard::OPEN_API_DOC[][src]

pub static OPEN_API_DOC: &str
\ No newline at end of file diff --git a/guard/static.PKG_DESCRIPTION.html b/guard/static.PKG_DESCRIPTION.html index a3606eb4..b9dbfb7d 100644 --- a/guard/static.PKG_DESCRIPTION.html +++ b/guard/static.PKG_DESCRIPTION.html @@ -1,5 +1,5 @@ guard::PKG_DESCRIPTION - Rust

Static guard::PKG_DESCRIPTION[][src]

pub static PKG_DESCRIPTION: &str
+ Change settings

Static guard::PKG_DESCRIPTION[][src]

pub static PKG_DESCRIPTION: &str
\ No newline at end of file diff --git a/guard/static.PKG_HOMEPAGE.html b/guard/static.PKG_HOMEPAGE.html index 70f8d54f..52ffaa8c 100644 --- a/guard/static.PKG_HOMEPAGE.html +++ b/guard/static.PKG_HOMEPAGE.html @@ -1,5 +1,5 @@ guard::PKG_HOMEPAGE - Rust

Static guard::PKG_HOMEPAGE[][src]

pub static PKG_HOMEPAGE: &str
+ Change settings

Static guard::PKG_HOMEPAGE[][src]

pub static PKG_HOMEPAGE: &str
\ No newline at end of file diff --git a/guard/static.PKG_NAME.html b/guard/static.PKG_NAME.html index 1372a69e..b90d9124 100644 --- a/guard/static.PKG_NAME.html +++ b/guard/static.PKG_NAME.html @@ -1,5 +1,5 @@ guard::PKG_NAME - Rust

Static guard::PKG_NAME[][src]

pub static PKG_NAME: &str
+ Change settings

Static guard::PKG_NAME[][src]

pub static PKG_NAME: &str
\ No newline at end of file diff --git a/guard/static.VERIFICATION_PATH.html b/guard/static.VERIFICATION_PATH.html index f595d145..71a657d3 100644 --- a/guard/static.VERIFICATION_PATH.html +++ b/guard/static.VERIFICATION_PATH.html @@ -1,5 +1,5 @@ guard::VERIFICATION_PATH - Rust

Static guard::VERIFICATION_PATH[][src]

pub static VERIFICATION_PATH: &str
+ Change settings

Static guard::VERIFICATION_PATH[][src]

pub static VERIFICATION_PATH: &str
\ No newline at end of file diff --git a/guard/static.VERSION.html b/guard/static.VERSION.html index 34601e94..a637a0b1 100644 --- a/guard/static.VERSION.html +++ b/guard/static.VERSION.html @@ -1,5 +1,5 @@ guard::VERSION - Rust

Static guard::VERSION[][src]

pub static VERSION: &str
+ Change settings

Static guard::VERSION[][src]

pub static VERSION: &str
\ No newline at end of file diff --git a/guard/struct.CSS.html b/guard/struct.CSS.html new file mode 100644 index 00000000..27b158f0 --- /dev/null +++ b/guard/struct.CSS.html @@ -0,0 +1,1369 @@ +guard::CSS - Rust + +

Struct guard::CSS[][src]

pub struct CSS {
+    __private_field: (),
+}

+ Fields

__private_field: ()

Methods from Deref<Target = &'static str>

pub const fn len(&self) -> usize1.0.0 (const: 1.32.0)[src]

Returns the length of self.

+

This length is in bytes, not chars or graphemes. In other words, +it may not be what a human considers the length of the string.

+

Examples

+

Basic usage:

+ +
+let len = "foo".len();
+assert_eq!(3, len);
+
+assert_eq!("ƒoo".len(), 4); // fancy f!
+assert_eq!("ƒoo".chars().count(), 3);
+

pub const fn is_empty(&self) -> bool1.0.0 (const: 1.32.0)[src]

Returns true if self has a length of zero bytes.

+

Examples

+

Basic usage:

+ +
+let s = "";
+assert!(s.is_empty());
+
+let s = "not empty";
+assert!(!s.is_empty());
+

pub fn is_char_boundary(&self, index: usize) -> bool1.9.0[src]

Checks that index-th byte is the first byte in a UTF-8 code point +sequence or the end of the string.

+

The start and end of the string (when index == self.len()) are +considered to be boundaries.

+

Returns false 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));
+

pub const fn as_bytes(&self) -> &[u8]1.0.0 (const: 1.32.0)[src]

Converts a string slice to a byte slice. To convert the byte slice back +into a string slice, use the from_utf8 function.

+

Examples

+

Basic usage:

+ +
+let bytes = "bors".as_bytes();
+assert_eq!(b"bors", bytes);
+

pub const fn as_ptr(&self) -> *const u81.0.0 (const: 1.32.0)[src]

Converts a string slice to a raw pointer.

+

As string slices are a slice of bytes, the raw pointer points to a +u8. This pointer will be pointing to the first byte of the string +slice.

+

The caller must ensure that the returned pointer is never written to. +If you need to mutate the contents of the string slice, use as_mut_ptr.

+

Examples

+

Basic usage:

+ +
+let s = "Hello";
+let ptr = s.as_ptr();
+

pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output> where
    I: SliceIndex<str>, 
1.20.0[src]

Returns a subslice of str.

+

This is the non-panicking alternative to indexing the str. Returns +None whenever equivalent indexing operation would panic.

+

Examples

+
+let v = String::from("🗻∈🌏");
+
+assert_eq!(Some("🗻"), v.get(0..4));
+
+// indices not on UTF-8 sequence boundaries
+assert!(v.get(1..).is_none());
+assert!(v.get(..8).is_none());
+
+// out of bounds
+assert!(v.get(..42).is_none());
+

pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output where
    I: SliceIndex<str>, 
1.20.0[src]

Returns an unchecked subslice of str.

+

This is the unchecked alternative to indexing the str.

+

Safety

+

Callers of this function are responsible that these preconditions are +satisfied:

+
    +
  • The starting index must not exceed the ending index;
  • +
  • Indexes must be within bounds of the original slice;
  • +
  • Indexes must lie on UTF-8 sequence boundaries.
  • +
+

Failing that, the returned string slice may reference invalid memory or +violate the invariants communicated by the str type.

+

Examples

+
+let v = "🗻∈🌏";
+unsafe {
+    assert_eq!("🗻", v.get_unchecked(0..4));
+    assert_eq!("∈", v.get_unchecked(4..7));
+    assert_eq!("🌏", v.get_unchecked(7..11));
+}
+

pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str1.0.0[src]

👎 Deprecated since 1.29.0:

use get_unchecked(begin..end) instead

+

Creates a string slice from another string slice, bypassing safety +checks.

+

This is generally not recommended, use with caution! For a safe +alternative see str and Index.

+

This new slice goes from begin to end, including begin but +excluding end.

+

To get a mutable string slice instead, see the +slice_mut_unchecked method.

+

Safety

+

Callers of this function are responsible that three preconditions are +satisfied:

+
    +
  • begin must not exceed end.
  • +
  • begin and end must be byte positions within the string slice.
  • +
  • begin and end must lie on UTF-8 sequence boundaries.
  • +
+

Examples

+

Basic usage:

+ +
+let s = "Löwe 老虎 Léopard";
+
+unsafe {
+    assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
+}
+
+let s = "Hello, world!";
+
+unsafe {
+    assert_eq!("world", s.slice_unchecked(7, 12));
+}
+

pub fn split_at(&self, mid: usize) -> (&str, &str)1.4.0[src]

Divide one string slice into two at an index.

+

The argument, mid, should be a byte offset from the start of the +string. It must also be on the boundary of a UTF-8 code point.

+

The two slices returned go from the start of the string slice to mid, +and from mid to the end of the string slice.

+

To get mutable string slices instead, see the split_at_mut +method.

+

Panics

+

Panics if mid is not on a UTF-8 code point boundary, or if it is +past the end of the last code point of the string slice.

+

Examples

+

Basic usage:

+ +
+let s = "Per Martin-Löf";
+
+let (first, last) = s.split_at(3);
+
+assert_eq!("Per", first);
+assert_eq!(" Martin-Löf", last);
+

pub fn chars(&self) -> Chars<'_>1.0.0[src]

Returns an iterator over the chars of a string slice.

+

As a string slice consists of valid UTF-8, we can iterate through a +string slice by char. This method returns such an iterator.

+

It's important to remember that char represents a Unicode Scalar +Value, and may not match your idea of what a 'character' is. Iteration +over grapheme clusters may be what you actually want. This functionality +is not provided by Rust's standard library, check crates.io instead.

+

Examples

+

Basic usage:

+ +
+let word = "goodbye";
+
+let count = word.chars().count();
+assert_eq!(7, count);
+
+let mut chars = word.chars();
+
+assert_eq!(Some('g'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('d'), chars.next());
+assert_eq!(Some('b'), chars.next());
+assert_eq!(Some('y'), chars.next());
+assert_eq!(Some('e'), chars.next());
+
+assert_eq!(None, chars.next());
+

Remember, chars may not match your intuition about characters:

+ +
+let y = "y̆";
+
+let mut chars = y.chars();
+
+assert_eq!(Some('y'), chars.next()); // not 'y̆'
+assert_eq!(Some('\u{0306}'), chars.next());
+
+assert_eq!(None, chars.next());
+

pub fn char_indices(&self) -> CharIndices<'_>1.0.0[src]

Returns an iterator over the chars of a string slice, and their +positions.

+

As a string slice consists of valid UTF-8, we can iterate through a +string slice by char. This method returns an iterator of both +these chars, as well as their byte positions.

+

The iterator yields tuples. The position is first, the char is +second.

+

Examples

+

Basic usage:

+ +
+let word = "goodbye";
+
+let count = word.char_indices().count();
+assert_eq!(7, count);
+
+let mut char_indices = word.char_indices();
+
+assert_eq!(Some((0, 'g')), char_indices.next());
+assert_eq!(Some((1, 'o')), char_indices.next());
+assert_eq!(Some((2, 'o')), char_indices.next());
+assert_eq!(Some((3, 'd')), char_indices.next());
+assert_eq!(Some((4, 'b')), char_indices.next());
+assert_eq!(Some((5, 'y')), char_indices.next());
+assert_eq!(Some((6, 'e')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+

Remember, chars may not match your intuition about characters:

+ +
+let yes = "y̆es";
+
+let mut char_indices = yes.char_indices();
+
+assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
+assert_eq!(Some((1, '\u{0306}')), char_indices.next());
+
+// note the 3 here - the last character took up two bytes
+assert_eq!(Some((3, 'e')), char_indices.next());
+assert_eq!(Some((4, 's')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+

pub fn bytes(&self) -> Bytes<'_>1.0.0[src]

An iterator over the bytes of a string slice.

+

As a string slice consists of a sequence of bytes, we can iterate +through a string slice by byte. This method returns such an iterator.

+

Examples

+

Basic usage:

+ +
+let mut bytes = "bors".bytes();
+
+assert_eq!(Some(b'b'), bytes.next());
+assert_eq!(Some(b'o'), bytes.next());
+assert_eq!(Some(b'r'), bytes.next());
+assert_eq!(Some(b's'), bytes.next());
+
+assert_eq!(None, bytes.next());
+

pub fn split_whitespace(&self) -> SplitWhitespace<'_>1.1.0[src]

Splits a string slice by whitespace.

+

The iterator returned will return string slices that are sub-slices of +the original string slice, separated by any amount of whitespace.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space. If you only want to split on ASCII whitespace +instead, use split_ascii_whitespace.

+

Examples

+

Basic usage:

+ +
+let mut iter = "A few words".split_whitespace();
+
+assert_eq!(Some("A"), iter.next());
+assert_eq!(Some("few"), iter.next());
+assert_eq!(Some("words"), iter.next());
+
+assert_eq!(None, iter.next());
+

All kinds of whitespace are considered:

+ +
+let mut iter = " Mary   had\ta\u{2009}little  \n\t lamb".split_whitespace();
+assert_eq!(Some("Mary"), iter.next());
+assert_eq!(Some("had"), iter.next());
+assert_eq!(Some("a"), iter.next());
+assert_eq!(Some("little"), iter.next());
+assert_eq!(Some("lamb"), iter.next());
+
+assert_eq!(None, iter.next());
+

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>1.34.0[src]

Splits a string slice by ASCII whitespace.

+

The iterator returned will return string slices that are sub-slices of +the original string slice, separated by any amount of ASCII whitespace.

+

To split by Unicode Whitespace instead, use split_whitespace.

+

Examples

+

Basic usage:

+ +
+let mut iter = "A few words".split_ascii_whitespace();
+
+assert_eq!(Some("A"), iter.next());
+assert_eq!(Some("few"), iter.next());
+assert_eq!(Some("words"), iter.next());
+
+assert_eq!(None, iter.next());
+

All kinds of ASCII whitespace are considered:

+ +
+let mut iter = " Mary   had\ta little  \n\t lamb".split_ascii_whitespace();
+assert_eq!(Some("Mary"), iter.next());
+assert_eq!(Some("had"), iter.next());
+assert_eq!(Some("a"), iter.next());
+assert_eq!(Some("little"), iter.next());
+assert_eq!(Some("lamb"), iter.next());
+
+assert_eq!(None, iter.next());
+

pub fn lines(&self) -> Lines<'_>1.0.0[src]

An iterator over the lines of a string, as string slices.

+

Lines are ended with either a newline (\n) or a carriage return with +a line feed (\r\n).

+

The final line ending is optional. A string that ends with a final line +ending will return the same lines as an otherwise identical string +without a final line ending.

+

Examples

+

Basic usage:

+ +
+let text = "foo\r\nbar\n\nbaz\n";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+

The final line ending isn't required:

+ +
+let text = "foo\nbar\n\r\nbaz";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+

pub fn lines_any(&self) -> LinesAny<'_>1.0.0[src]

👎 Deprecated since 1.4.0:

use lines() instead now

+

An iterator over the lines of a string.

+

pub fn encode_utf16(&self) -> EncodeUtf16<'_>1.8.0[src]

Returns an iterator of u16 over the string encoded as UTF-16.

+

Examples

+

Basic usage:

+ +
+let text = "Zażółć gęślą jaźń";
+
+let utf8_len = text.len();
+let utf16_len = text.encode_utf16().count();
+
+assert!(utf16_len <= utf8_len);
+

pub fn contains<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>, 
1.0.0[src]

Returns true if the given pattern matches a sub-slice of +this string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.contains("nana"));
+assert!(!bananas.contains("apples"));
+

pub fn starts_with<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>, 
1.0.0[src]

Returns true if the given pattern matches a prefix of this +string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.starts_with("bana"));
+assert!(!bananas.starts_with("nana"));
+

pub fn ends_with<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

Returns true if the given pattern matches a suffix of this +string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.ends_with("anas"));
+assert!(!bananas.ends_with("nana"));
+

pub fn find<'a, P>(&'a self, pat: P) -> Option<usize> where
    P: Pattern<'a>, 
1.0.0[src]

Returns the byte index of the first character of this string slice that +matches the pattern.

+

Returns None if the pattern doesn't match.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Simple patterns:

+ +
+let s = "Löwe 老虎 Léopard Gepardi";
+
+assert_eq!(s.find('L'), Some(0));
+assert_eq!(s.find('é'), Some(14));
+assert_eq!(s.find("pard"), Some(17));
+

More complex patterns using point-free style and 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));
+assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
+assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
+

Not finding the pattern:

+ +
+let s = "Löwe 老虎 Léopard";
+let x: &[_] = &['1', '2'];
+
+assert_eq!(s.find(x), None);
+

pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

Returns the byte index for the first character of the rightmost match of the pattern in +this string slice.

+

Returns None if the pattern doesn't match.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Simple patterns:

+ +
+let s = "Löwe 老虎 Léopard Gepardi";
+
+assert_eq!(s.rfind('L'), Some(13));
+assert_eq!(s.rfind('é'), Some(14));
+assert_eq!(s.rfind("pard"), Some(24));
+

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

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of this string slice, separated by +characters matched by a pattern.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rsplit method 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"]);
+

If the pattern is a slice of chars, split on each occurrence of any of the characters:

+ +
+let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
+assert_eq!(v, ["2020", "11", "03", "23", "59"]);
+

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

Contiguous separators are separated by the empty string.

+ +
+let x = "(///)".to_string();
+let d: Vec<_> = x.split('/').collect();
+
+assert_eq!(d, &["(", "", "", ")"]);
+

Separators at the start or end of a string are neighbored +by empty strings.

+ +
+let d: Vec<_> = "010".split("0").collect();
+assert_eq!(d, &["", "1", ""]);
+

When the empty string is used as a separator, it separates +every character in the string, along with the beginning +and end of the string.

+ +
+let f: Vec<_> = "rust".split("").collect();
+assert_eq!(f, &["", "r", "u", "s", "t", ""]);
+

Contiguous separators 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"]);
+

Use split_whitespace for this behavior.

+

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> where
    P: Pattern<'a>, 
1.51.0[src]

An iterator over substrings of this string slice, separated by +characters matched by a pattern. Differs from the iterator produced by +split in that split_inclusive leaves the matched part as the +terminator of the substring.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
+    .split_inclusive('\n').collect();
+assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
+

If the last element of the string is matched, +that element will be considered the terminator of the preceding substring. +That substring will be the last item returned by the iterator.

+ +
+let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
+    .split_inclusive('\n').collect();
+assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
+

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by +characters matched by a pattern and yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the split method 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"]);
+

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by +characters matched by a pattern.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

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 a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rsplit_terminator method can be used.

+

Examples

+

Basic usage:

+ +
+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", ""]);
+

pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of self, separated by characters +matched by a pattern and yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

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, the split_terminator method 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"]);
+

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by a +pattern, restricted to returning at most n items.

+

If n substrings are returned, the last substring (the nth substring) +will contain the remainder of the string.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will not be double ended, because it is +not efficient to support.

+

If the pattern allows a reverse search, the rsplitn method 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"]);
+

pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of this string slice, separated by a +pattern, starting from the end of the string, restricted to returning +at most n items.

+

If n substrings are returned, the last substring (the nth substring) +will contain the remainder of the string.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will not be double ended, because it is not +efficient to support.

+

For splitting from the front, the splitn method can be used.

+

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

pub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> where
    P: Pattern<'a>, 
[src]

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

newly added

+

Splits the string on the first occurrence of the specified delimiter and +returns prefix before delimiter and suffix after delimiter.

+

Examples

+
+#![feature(str_split_once)]
+
+assert_eq!("cfg".split_once('='), None);
+assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
+assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));
+

pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
[src]

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

newly added

+

Splits the string on the last occurrence of the specified delimiter and +returns prefix before delimiter and suffix after delimiter.

+

Examples

+
+#![feature(str_split_once)]
+
+assert_eq!("cfg".rsplit_once('='), None);
+assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));
+assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));
+

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where
    P: Pattern<'a>, 
1.2.0[src]

An iterator over the disjoint matches of a pattern within the given string +slice.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rmatches method can be used.

+

Examples

+

Basic usage:

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

pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.2.0[src]

An iterator over the disjoint matches of a pattern within this string slice, +yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the matches method can be used.

+

Examples

+

Basic usage:

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

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where
    P: Pattern<'a>, 
1.5.0[src]

An iterator over the disjoint matches of a pattern within this string +slice as well as the index that the match starts at.

+

For matches of pat within self that overlap, only the indices +corresponding to the first match are returned.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rmatch_indices method can be used.

+

Examples

+

Basic usage:

+ +
+let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
+assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
+
+let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
+assert_eq!(v, [(1, "abc"), (4, "abc")]);
+
+let v: Vec<_> = "ababa".match_indices("aba").collect();
+assert_eq!(v, [(0, "aba")]); // only the first `aba`
+

pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.5.0[src]

An iterator over the disjoint matches of a pattern within self, +yielded in reverse order along with the index of the match.

+

For matches of pat within self that overlap, only the indices +corresponding to the last match are returned.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the match_indices method can be used.

+

Examples

+

Basic usage:

+ +
+let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
+assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
+
+let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
+assert_eq!(v, [(4, "abc"), (1, "abc")]);
+
+let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
+assert_eq!(v, [(2, "aba")]); // only the last `aba`
+

#[must_use = + "this returns the trimmed string as a slice, \ + without modifying the original"]pub fn trim(&self) -> &str1.0.0[src]

Returns a string slice with leading and trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld", s.trim());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_start(&self) -> &str1.30.0[src]

Returns a string slice with leading whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. start in this context means the first +position of that byte string; for a left-to-right language like English or +Russian, this will be left side, and for right-to-left languages like +Arabic or Hebrew, this will be the right side.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+assert_eq!("Hello\tworld\t", s.trim_start());
+

Directionality:

+ +
+let s = "  English  ";
+assert!(Some('E') == s.trim_start().chars().next());
+
+let s = "  עברית  ";
+assert!(Some('ע') == s.trim_start().chars().next());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_end(&self) -> &str1.30.0[src]

Returns a string slice with trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. end in this context means the last +position of that byte string; for a left-to-right language like English or +Russian, this will be right side, and for right-to-left languages like +Arabic or Hebrew, this will be the left side.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+assert_eq!(" Hello\tworld", s.trim_end());
+

Directionality:

+ +
+let s = "  English  ";
+assert!(Some('h') == s.trim_end().chars().rev().next());
+
+let s = "  עברית  ";
+assert!(Some('ת') == s.trim_end().chars().rev().next());
+

pub fn trim_left(&self) -> &str1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_start

+

Returns a string slice with leading whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. 'Left' in this context means the first +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the right side, not the left.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld\t", s.trim_left());
+

Directionality:

+ +
+let s = "  English";
+assert!(Some('E') == s.trim_left().chars().next());
+
+let s = "  עברית";
+assert!(Some('ע') == s.trim_left().chars().next());
+

pub fn trim_right(&self) -> &str1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_end

+

Returns a string slice with trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. 'Right' in this context means the last +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the left side, not the right.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!(" Hello\tworld", s.trim_right());
+

Directionality:

+ +
+let s = "English  ";
+assert!(Some('h') == s.trim_right().chars().rev().next());
+
+let s = "עברית  ";
+assert!(Some('ת') == s.trim_right().chars().rev().next());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 
1.0.0[src]

Returns a string slice with all prefixes and suffixes that match a +pattern repeatedly removed.

+

The pattern can be a char, a slice of chars, or a function +or closure that determines if a character matches.

+

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

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>, 
1.30.0[src]

Returns a string slice with all prefixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. start in this context means the first +position of that byte string; for a left-to-right language like English or +Russian, this will be left side, and for right-to-left languages like +Arabic or Hebrew, this will be the right side.

+

Examples

+

Basic usage:

+ +
+assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
+assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
+

#[must_use = + "this returns the remaining substring as a new slice, \ + without modifying the original"]pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str> where
    P: Pattern<'a>, 
1.45.0[src]

Returns a string slice with the prefix removed.

+

If the string starts with the pattern prefix, returns substring after the prefix, wrapped +in Some. Unlike trim_start_matches, this method removes the prefix exactly once.

+

If the string does not start with prefix, returns None.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
+assert_eq!("foo:bar".strip_prefix("bar"), None);
+assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
+

#[must_use = + "this returns the remaining substring as a new slice, \ + without modifying the original"]pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.45.0[src]

Returns a string slice with the suffix removed.

+

If the string ends with the pattern suffix, returns the substring before the suffix, +wrapped in Some. Unlike trim_end_matches, this method removes the suffix exactly once.

+

If the string does not end with suffix, returns None.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
+assert_eq!("bar:foo".strip_suffix("bar"), None);
+assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.30.0[src]

Returns a string slice with all suffixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. end in this context means the last +position of that byte string; for a left-to-right language like English or +Russian, this will be right side, and for right-to-left languages like +Arabic or Hebrew, this will be the left side.

+

Examples

+

Simple patterns:

+ +
+assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
+assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");
+

A more complex pattern, using a closure:

+ +
+assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
+

pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>, 
1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_start_matches

+

Returns a string slice with all prefixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. 'Left' in this context means the first +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the right side, not the left.

+

Examples

+

Basic usage:

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

pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_end_matches

+

Returns a string slice with all suffixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. 'Right' in this context means the last +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the left side, not the right.

+

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_right_matches(|c| c == '1' || c == 'X'), "1foo");
+

pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err> where
    F: FromStr
1.0.0[src]

Parses this string slice into another type.

+

Because parse is so general, it can cause problems with type +inference. As such, parse is one of the few times you'll see +the syntax affectionately known as the 'turbofish': ::<>. This +helps the inference algorithm understand specifically which type +you're trying to parse into.

+

parse can parse into any type that implements the FromStr trait.

+

Errors

+

Will return Err if it's not possible to parse this string slice into +the desired type.

+

Examples

+

Basic usage

+ +
+let four: u32 = "4".parse().unwrap();
+
+assert_eq!(4, four);
+

Using the 'turbofish' instead of annotating four:

+ +
+let four = "4".parse::<u32>();
+
+assert_eq!(Ok(4), four);
+

Failing to parse:

+ +
+let nope = "j".parse::<u32>();
+
+assert!(nope.is_err());
+

pub fn is_ascii(&self) -> bool1.23.0[src]

Checks if all characters in this string are within the ASCII range.

+

Examples

+
+let ascii = "hello!\n";
+let non_ascii = "Grüße, Jürgen ❤";
+
+assert!(ascii.is_ascii());
+assert!(!non_ascii.is_ascii());
+

pub fn eq_ignore_ascii_case(&self, other: &str) -> bool1.23.0[src]

Checks that two strings are an ASCII case-insensitive match.

+

Same as to_ascii_lowercase(a) == to_ascii_lowercase(b), +but without allocating and copying temporaries.

+

Examples

+
+assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
+assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
+assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));
+

pub fn escape_debug(&self) -> EscapeDebug<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_debug.

+

Note: only extended grapheme codepoints that begin the string will be +escaped.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_debug() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_debug());
+

Both are equivalent to:

+ +
+println!("❤\\n!");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
+

pub fn escape_default(&self) -> EscapeDefault<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_default.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_default() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_default());
+

Both are equivalent to:

+ +
+println!("\\u{{2764}}\\n!");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
+

pub fn escape_unicode(&self) -> EscapeUnicode<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_unicode.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_unicode() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_unicode());
+

Both are equivalent to:

+ +
+println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
+

#[must_use = + "this returns the replaced string as a new allocation, \ + without modifying the original"]pub fn replace<'a, P>(&'a self, from: P, to: &str) -> String where
    P: Pattern<'a>, 
1.0.0[src]

Replaces all matches of a pattern with another string.

+

replace creates a new String, and copies the data from this string slice into it. +While doing so, it attempts to find matches of a pattern. If it finds any, it +replaces them with the replacement string slice.

+

Examples

+

Basic usage:

+ +
+let s = "this is old";
+
+assert_eq!("this is new", s.replace("old", "new"));
+

When the pattern doesn't match:

+ +
+let s = "this is old";
+assert_eq!(s, s.replace("cookie monster", "little lamb"));
+

#[must_use = + "this returns the replaced string as a new allocation, \ + without modifying the original"]pub fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String where
    P: Pattern<'a>, 
1.16.0[src]

Replaces first N matches of a pattern with another string.

+

replacen creates a new String, and copies the data from this string slice into it. +While doing so, it attempts to find matches of a pattern. If it finds any, it +replaces them with the replacement string slice at most count times.

+

Examples

+

Basic usage:

+ +
+let s = "foo foo 123 foo";
+assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
+assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
+assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));
+

When the pattern doesn't match:

+ +
+let s = "this is old";
+assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
+

pub fn to_lowercase(&self) -> String1.2.0[src]

Returns the lowercase equivalent of this string slice, as a new String.

+

'Lowercase' is defined according to the terms of the Unicode Derived Core Property +Lowercase.

+

Since some characters can expand into multiple characters when changing +the case, this function returns a String instead of modifying the +parameter in-place.

+

Examples

+

Basic usage:

+ +
+let s = "HELLO";
+
+assert_eq!("hello", s.to_lowercase());
+

A tricky example, with sigma:

+ +
+let sigma = "Σ";
+
+assert_eq!("σ", sigma.to_lowercase());
+
+// but at the end of a word, it's ς, not σ:
+let odysseus = "ὈΔΥΣΣΕΎΣ";
+
+assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
+

Languages without case are not changed:

+ +
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_lowercase());
+

pub fn to_uppercase(&self) -> String1.2.0[src]

Returns the uppercase equivalent of this string slice, as a new String.

+

'Uppercase' is defined according to the terms of the Unicode Derived Core Property +Uppercase.

+

Since some characters can expand into multiple characters when changing +the case, this function returns a String instead of modifying the +parameter in-place.

+

Examples

+

Basic usage:

+ +
+let s = "hello";
+
+assert_eq!("HELLO", s.to_uppercase());
+

Scripts without case are not changed:

+ +
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_uppercase());
+

One character can become multiple:

+ +
+let s = "tschüß";
+
+assert_eq!("TSCHÜSS", s.to_uppercase());
+

pub fn repeat(&self, n: usize) -> String1.16.0[src]

Creates a new String by repeating a string n times.

+

Panics

+

This function will panic if the capacity would overflow.

+

Examples

+

Basic usage:

+ +
+assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
+

A panic upon overflow:

+ +
+// this will panic at runtime
+"0123456789abcdef".repeat(usize::MAX);
+

pub fn to_ascii_uppercase(&self) -> String1.23.0[src]

Returns a copy of this string where each character is mapped to its +ASCII upper case equivalent.

+

ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', +but non-ASCII letters are unchanged.

+

To uppercase the value in-place, use make_ascii_uppercase.

+

To uppercase ASCII characters in addition to non-ASCII characters, use +to_uppercase.

+

Examples

+
+let s = "Grüße, Jürgen ❤";
+
+assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
+

pub fn to_ascii_lowercase(&self) -> String1.23.0[src]

Returns a copy of this string where each character is mapped to its +ASCII lower case equivalent.

+

ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', +but non-ASCII letters are unchanged.

+

To lowercase the value in-place, use make_ascii_lowercase.

+

To lowercase ASCII characters in addition to non-ASCII characters, use +to_lowercase.

+

Examples

+
+let s = "Grüße, Jürgen ❤";
+
+assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
+

Trait Implementations

impl Deref for CSS[src]

type Target = &'static str

The resulting type after dereferencing.

+

impl LazyStatic for CSS[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Conv for T

impl<T> Conv for T

impl<T> FmtForward for T

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pipe for T where
    T: ?Sized

impl<T> Pipe for T

impl<T> PipeAsRef for T

impl<T> PipeBorrow for T

impl<T> PipeDeref for T

impl<T> PipeRef for T

impl<T> Same<T> for T

type Output = T

Should always be Self

+

impl<T> Tap for T

impl<T> Tap for T

impl<T, U> TapAsRef<U> for T where
    U: ?Sized

impl<T, U> TapBorrow<U> for T where
    U: ?Sized

impl<T> TapDeref for T

impl<T> TryConv for T

impl<T> TryConv for T

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

+ \ No newline at end of file diff --git a/guard/struct.FILES.html b/guard/struct.FILES.html new file mode 100644 index 00000000..f2f6e89c --- /dev/null +++ b/guard/struct.FILES.html @@ -0,0 +1,117 @@ +guard::FILES - Rust + +

Struct guard::FILES[][src]

pub struct FILES {
+    __private_field: (),
+}

+ Fields

__private_field: ()

Methods from Deref<Target = FileMap>

pub fn get(&'a self, path: &'a str) -> Option<&'a str>

pub fn get_full_path(&'a self, path: &'a str) -> Option<&'a String>

pub fn to_env(&self)

Trait Implementations

impl Deref for FILES[src]

type Target = FileMap

The resulting type after dereferencing.

+

impl LazyStatic for FILES[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Conv for T

impl<T> Conv for T

impl<T> FmtForward for T

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pipe for T where
    T: ?Sized

impl<T> Pipe for T

impl<T> PipeAsRef for T

impl<T> PipeBorrow for T

impl<T> PipeDeref for T

impl<T> PipeRef for T

impl<T> Same<T> for T

type Output = T

Should always be Self

+

impl<T> Tap for T

impl<T> Tap for T

impl<T, U> TapAsRef<U> for T where
    U: ?Sized

impl<T, U> TapBorrow<U> for T where
    U: ?Sized

impl<T> TapDeref for T

impl<T> TryConv for T

impl<T> TryConv for T

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

+ \ No newline at end of file diff --git a/guard/struct.JS.html b/guard/struct.JS.html new file mode 100644 index 00000000..37b15344 --- /dev/null +++ b/guard/struct.JS.html @@ -0,0 +1,1369 @@ +guard::JS - Rust + +

Struct guard::JS[][src]

pub struct JS {
+    __private_field: (),
+}

+ Fields

__private_field: ()

Methods from Deref<Target = &'static str>

pub const fn len(&self) -> usize1.0.0 (const: 1.32.0)[src]

Returns the length of self.

+

This length is in bytes, not chars or graphemes. In other words, +it may not be what a human considers the length of the string.

+

Examples

+

Basic usage:

+ +
+let len = "foo".len();
+assert_eq!(3, len);
+
+assert_eq!("ƒoo".len(), 4); // fancy f!
+assert_eq!("ƒoo".chars().count(), 3);
+

pub const fn is_empty(&self) -> bool1.0.0 (const: 1.32.0)[src]

Returns true if self has a length of zero bytes.

+

Examples

+

Basic usage:

+ +
+let s = "";
+assert!(s.is_empty());
+
+let s = "not empty";
+assert!(!s.is_empty());
+

pub fn is_char_boundary(&self, index: usize) -> bool1.9.0[src]

Checks that index-th byte is the first byte in a UTF-8 code point +sequence or the end of the string.

+

The start and end of the string (when index == self.len()) are +considered to be boundaries.

+

Returns false 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));
+

pub const fn as_bytes(&self) -> &[u8]1.0.0 (const: 1.32.0)[src]

Converts a string slice to a byte slice. To convert the byte slice back +into a string slice, use the from_utf8 function.

+

Examples

+

Basic usage:

+ +
+let bytes = "bors".as_bytes();
+assert_eq!(b"bors", bytes);
+

pub const fn as_ptr(&self) -> *const u81.0.0 (const: 1.32.0)[src]

Converts a string slice to a raw pointer.

+

As string slices are a slice of bytes, the raw pointer points to a +u8. This pointer will be pointing to the first byte of the string +slice.

+

The caller must ensure that the returned pointer is never written to. +If you need to mutate the contents of the string slice, use as_mut_ptr.

+

Examples

+

Basic usage:

+ +
+let s = "Hello";
+let ptr = s.as_ptr();
+

pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output> where
    I: SliceIndex<str>, 
1.20.0[src]

Returns a subslice of str.

+

This is the non-panicking alternative to indexing the str. Returns +None whenever equivalent indexing operation would panic.

+

Examples

+
+let v = String::from("🗻∈🌏");
+
+assert_eq!(Some("🗻"), v.get(0..4));
+
+// indices not on UTF-8 sequence boundaries
+assert!(v.get(1..).is_none());
+assert!(v.get(..8).is_none());
+
+// out of bounds
+assert!(v.get(..42).is_none());
+

pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output where
    I: SliceIndex<str>, 
1.20.0[src]

Returns an unchecked subslice of str.

+

This is the unchecked alternative to indexing the str.

+

Safety

+

Callers of this function are responsible that these preconditions are +satisfied:

+
    +
  • The starting index must not exceed the ending index;
  • +
  • Indexes must be within bounds of the original slice;
  • +
  • Indexes must lie on UTF-8 sequence boundaries.
  • +
+

Failing that, the returned string slice may reference invalid memory or +violate the invariants communicated by the str type.

+

Examples

+
+let v = "🗻∈🌏";
+unsafe {
+    assert_eq!("🗻", v.get_unchecked(0..4));
+    assert_eq!("∈", v.get_unchecked(4..7));
+    assert_eq!("🌏", v.get_unchecked(7..11));
+}
+

pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str1.0.0[src]

👎 Deprecated since 1.29.0:

use get_unchecked(begin..end) instead

+

Creates a string slice from another string slice, bypassing safety +checks.

+

This is generally not recommended, use with caution! For a safe +alternative see str and Index.

+

This new slice goes from begin to end, including begin but +excluding end.

+

To get a mutable string slice instead, see the +slice_mut_unchecked method.

+

Safety

+

Callers of this function are responsible that three preconditions are +satisfied:

+
    +
  • begin must not exceed end.
  • +
  • begin and end must be byte positions within the string slice.
  • +
  • begin and end must lie on UTF-8 sequence boundaries.
  • +
+

Examples

+

Basic usage:

+ +
+let s = "Löwe 老虎 Léopard";
+
+unsafe {
+    assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
+}
+
+let s = "Hello, world!";
+
+unsafe {
+    assert_eq!("world", s.slice_unchecked(7, 12));
+}
+

pub fn split_at(&self, mid: usize) -> (&str, &str)1.4.0[src]

Divide one string slice into two at an index.

+

The argument, mid, should be a byte offset from the start of the +string. It must also be on the boundary of a UTF-8 code point.

+

The two slices returned go from the start of the string slice to mid, +and from mid to the end of the string slice.

+

To get mutable string slices instead, see the split_at_mut +method.

+

Panics

+

Panics if mid is not on a UTF-8 code point boundary, or if it is +past the end of the last code point of the string slice.

+

Examples

+

Basic usage:

+ +
+let s = "Per Martin-Löf";
+
+let (first, last) = s.split_at(3);
+
+assert_eq!("Per", first);
+assert_eq!(" Martin-Löf", last);
+

pub fn chars(&self) -> Chars<'_>1.0.0[src]

Returns an iterator over the chars of a string slice.

+

As a string slice consists of valid UTF-8, we can iterate through a +string slice by char. This method returns such an iterator.

+

It's important to remember that char represents a Unicode Scalar +Value, and may not match your idea of what a 'character' is. Iteration +over grapheme clusters may be what you actually want. This functionality +is not provided by Rust's standard library, check crates.io instead.

+

Examples

+

Basic usage:

+ +
+let word = "goodbye";
+
+let count = word.chars().count();
+assert_eq!(7, count);
+
+let mut chars = word.chars();
+
+assert_eq!(Some('g'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('d'), chars.next());
+assert_eq!(Some('b'), chars.next());
+assert_eq!(Some('y'), chars.next());
+assert_eq!(Some('e'), chars.next());
+
+assert_eq!(None, chars.next());
+

Remember, chars may not match your intuition about characters:

+ +
+let y = "y̆";
+
+let mut chars = y.chars();
+
+assert_eq!(Some('y'), chars.next()); // not 'y̆'
+assert_eq!(Some('\u{0306}'), chars.next());
+
+assert_eq!(None, chars.next());
+

pub fn char_indices(&self) -> CharIndices<'_>1.0.0[src]

Returns an iterator over the chars of a string slice, and their +positions.

+

As a string slice consists of valid UTF-8, we can iterate through a +string slice by char. This method returns an iterator of both +these chars, as well as their byte positions.

+

The iterator yields tuples. The position is first, the char is +second.

+

Examples

+

Basic usage:

+ +
+let word = "goodbye";
+
+let count = word.char_indices().count();
+assert_eq!(7, count);
+
+let mut char_indices = word.char_indices();
+
+assert_eq!(Some((0, 'g')), char_indices.next());
+assert_eq!(Some((1, 'o')), char_indices.next());
+assert_eq!(Some((2, 'o')), char_indices.next());
+assert_eq!(Some((3, 'd')), char_indices.next());
+assert_eq!(Some((4, 'b')), char_indices.next());
+assert_eq!(Some((5, 'y')), char_indices.next());
+assert_eq!(Some((6, 'e')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+

Remember, chars may not match your intuition about characters:

+ +
+let yes = "y̆es";
+
+let mut char_indices = yes.char_indices();
+
+assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
+assert_eq!(Some((1, '\u{0306}')), char_indices.next());
+
+// note the 3 here - the last character took up two bytes
+assert_eq!(Some((3, 'e')), char_indices.next());
+assert_eq!(Some((4, 's')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+

pub fn bytes(&self) -> Bytes<'_>1.0.0[src]

An iterator over the bytes of a string slice.

+

As a string slice consists of a sequence of bytes, we can iterate +through a string slice by byte. This method returns such an iterator.

+

Examples

+

Basic usage:

+ +
+let mut bytes = "bors".bytes();
+
+assert_eq!(Some(b'b'), bytes.next());
+assert_eq!(Some(b'o'), bytes.next());
+assert_eq!(Some(b'r'), bytes.next());
+assert_eq!(Some(b's'), bytes.next());
+
+assert_eq!(None, bytes.next());
+

pub fn split_whitespace(&self) -> SplitWhitespace<'_>1.1.0[src]

Splits a string slice by whitespace.

+

The iterator returned will return string slices that are sub-slices of +the original string slice, separated by any amount of whitespace.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space. If you only want to split on ASCII whitespace +instead, use split_ascii_whitespace.

+

Examples

+

Basic usage:

+ +
+let mut iter = "A few words".split_whitespace();
+
+assert_eq!(Some("A"), iter.next());
+assert_eq!(Some("few"), iter.next());
+assert_eq!(Some("words"), iter.next());
+
+assert_eq!(None, iter.next());
+

All kinds of whitespace are considered:

+ +
+let mut iter = " Mary   had\ta\u{2009}little  \n\t lamb".split_whitespace();
+assert_eq!(Some("Mary"), iter.next());
+assert_eq!(Some("had"), iter.next());
+assert_eq!(Some("a"), iter.next());
+assert_eq!(Some("little"), iter.next());
+assert_eq!(Some("lamb"), iter.next());
+
+assert_eq!(None, iter.next());
+

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>1.34.0[src]

Splits a string slice by ASCII whitespace.

+

The iterator returned will return string slices that are sub-slices of +the original string slice, separated by any amount of ASCII whitespace.

+

To split by Unicode Whitespace instead, use split_whitespace.

+

Examples

+

Basic usage:

+ +
+let mut iter = "A few words".split_ascii_whitespace();
+
+assert_eq!(Some("A"), iter.next());
+assert_eq!(Some("few"), iter.next());
+assert_eq!(Some("words"), iter.next());
+
+assert_eq!(None, iter.next());
+

All kinds of ASCII whitespace are considered:

+ +
+let mut iter = " Mary   had\ta little  \n\t lamb".split_ascii_whitespace();
+assert_eq!(Some("Mary"), iter.next());
+assert_eq!(Some("had"), iter.next());
+assert_eq!(Some("a"), iter.next());
+assert_eq!(Some("little"), iter.next());
+assert_eq!(Some("lamb"), iter.next());
+
+assert_eq!(None, iter.next());
+

pub fn lines(&self) -> Lines<'_>1.0.0[src]

An iterator over the lines of a string, as string slices.

+

Lines are ended with either a newline (\n) or a carriage return with +a line feed (\r\n).

+

The final line ending is optional. A string that ends with a final line +ending will return the same lines as an otherwise identical string +without a final line ending.

+

Examples

+

Basic usage:

+ +
+let text = "foo\r\nbar\n\nbaz\n";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+

The final line ending isn't required:

+ +
+let text = "foo\nbar\n\r\nbaz";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+

pub fn lines_any(&self) -> LinesAny<'_>1.0.0[src]

👎 Deprecated since 1.4.0:

use lines() instead now

+

An iterator over the lines of a string.

+

pub fn encode_utf16(&self) -> EncodeUtf16<'_>1.8.0[src]

Returns an iterator of u16 over the string encoded as UTF-16.

+

Examples

+

Basic usage:

+ +
+let text = "Zażółć gęślą jaźń";
+
+let utf8_len = text.len();
+let utf16_len = text.encode_utf16().count();
+
+assert!(utf16_len <= utf8_len);
+

pub fn contains<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>, 
1.0.0[src]

Returns true if the given pattern matches a sub-slice of +this string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.contains("nana"));
+assert!(!bananas.contains("apples"));
+

pub fn starts_with<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>, 
1.0.0[src]

Returns true if the given pattern matches a prefix of this +string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.starts_with("bana"));
+assert!(!bananas.starts_with("nana"));
+

pub fn ends_with<'a, P>(&'a self, pat: P) -> bool where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

Returns true if the given pattern matches a suffix of this +string slice.

+

Returns false if it does not.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Basic usage:

+ +
+let bananas = "bananas";
+
+assert!(bananas.ends_with("anas"));
+assert!(!bananas.ends_with("nana"));
+

pub fn find<'a, P>(&'a self, pat: P) -> Option<usize> where
    P: Pattern<'a>, 
1.0.0[src]

Returns the byte index of the first character of this string slice that +matches the pattern.

+

Returns None if the pattern doesn't match.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Simple patterns:

+ +
+let s = "Löwe 老虎 Léopard Gepardi";
+
+assert_eq!(s.find('L'), Some(0));
+assert_eq!(s.find('é'), Some(14));
+assert_eq!(s.find("pard"), Some(17));
+

More complex patterns using point-free style and 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));
+assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
+assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
+

Not finding the pattern:

+ +
+let s = "Löwe 老虎 Léopard";
+let x: &[_] = &['1', '2'];
+
+assert_eq!(s.find(x), None);
+

pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

Returns the byte index for the first character of the rightmost match of the pattern in +this string slice.

+

Returns None if the pattern doesn't match.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+

Simple patterns:

+ +
+let s = "Löwe 老虎 Léopard Gepardi";
+
+assert_eq!(s.rfind('L'), Some(13));
+assert_eq!(s.rfind('é'), Some(14));
+assert_eq!(s.rfind("pard"), Some(24));
+

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

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of this string slice, separated by +characters matched by a pattern.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rsplit method 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"]);
+

If the pattern is a slice of chars, split on each occurrence of any of the characters:

+ +
+let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
+assert_eq!(v, ["2020", "11", "03", "23", "59"]);
+

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

Contiguous separators are separated by the empty string.

+ +
+let x = "(///)".to_string();
+let d: Vec<_> = x.split('/').collect();
+
+assert_eq!(d, &["(", "", "", ")"]);
+

Separators at the start or end of a string are neighbored +by empty strings.

+ +
+let d: Vec<_> = "010".split("0").collect();
+assert_eq!(d, &["", "1", ""]);
+

When the empty string is used as a separator, it separates +every character in the string, along with the beginning +and end of the string.

+ +
+let f: Vec<_> = "rust".split("").collect();
+assert_eq!(f, &["", "r", "u", "s", "t", ""]);
+

Contiguous separators 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"]);
+

Use split_whitespace for this behavior.

+

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> where
    P: Pattern<'a>, 
1.51.0[src]

An iterator over substrings of this string slice, separated by +characters matched by a pattern. Differs from the iterator produced by +split in that split_inclusive leaves the matched part as the +terminator of the substring.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
+    .split_inclusive('\n').collect();
+assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
+

If the last element of the string is matched, +that element will be considered the terminator of the preceding substring. +That substring will be the last item returned by the iterator.

+ +
+let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
+    .split_inclusive('\n').collect();
+assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
+

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by +characters matched by a pattern and yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the split method 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"]);
+

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by +characters matched by a pattern.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

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 a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rsplit_terminator method can be used.

+

Examples

+

Basic usage:

+ +
+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", ""]);
+

pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of self, separated by characters +matched by a pattern and yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

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, the split_terminator method 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"]);
+

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> where
    P: Pattern<'a>, 
1.0.0[src]

An iterator over substrings of the given string slice, separated by a +pattern, restricted to returning at most n items.

+

If n substrings are returned, the last substring (the nth substring) +will contain the remainder of the string.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will not be double ended, because it is +not efficient to support.

+

If the pattern allows a reverse search, the rsplitn method 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"]);
+

pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

An iterator over substrings of this string slice, separated by a +pattern, starting from the end of the string, restricted to returning +at most n items.

+

If n substrings are returned, the last substring (the nth substring) +will contain the remainder of the string.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will not be double ended, because it is not +efficient to support.

+

For splitting from the front, the splitn method can be used.

+

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

pub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> where
    P: Pattern<'a>, 
[src]

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

newly added

+

Splits the string on the first occurrence of the specified delimiter and +returns prefix before delimiter and suffix after delimiter.

+

Examples

+
+#![feature(str_split_once)]
+
+assert_eq!("cfg".split_once('='), None);
+assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
+assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));
+

pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
[src]

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

newly added

+

Splits the string on the last occurrence of the specified delimiter and +returns prefix before delimiter and suffix after delimiter.

+

Examples

+
+#![feature(str_split_once)]
+
+assert_eq!("cfg".rsplit_once('='), None);
+assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));
+assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));
+

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where
    P: Pattern<'a>, 
1.2.0[src]

An iterator over the disjoint matches of a pattern within the given string +slice.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rmatches method can be used.

+

Examples

+

Basic usage:

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

pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.2.0[src]

An iterator over the disjoint matches of a pattern within this string slice, +yielded in reverse order.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the matches method can be used.

+

Examples

+

Basic usage:

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

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where
    P: Pattern<'a>, 
1.5.0[src]

An iterator over the disjoint matches of a pattern within this string +slice as well as the index that the match starts at.

+

For matches of pat within self that overlap, only the indices +corresponding to the first match are returned.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator will be a DoubleEndedIterator if the pattern +allows a reverse search and forward/reverse search yields the same +elements. This is true for, e.g., char, but not for &str.

+

If the pattern allows a reverse search but its results might differ +from a forward search, the rmatch_indices method can be used.

+

Examples

+

Basic usage:

+ +
+let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
+assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
+
+let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
+assert_eq!(v, [(1, "abc"), (4, "abc")]);
+
+let v: Vec<_> = "ababa".match_indices("aba").collect();
+assert_eq!(v, [(0, "aba")]); // only the first `aba`
+

pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.5.0[src]

An iterator over the disjoint matches of a pattern within self, +yielded in reverse order along with the index of the match.

+

For matches of pat within self that overlap, only the indices +corresponding to the last match are returned.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Iterator behavior

+

The returned iterator requires that the pattern supports a reverse +search, and it will be a DoubleEndedIterator if a forward/reverse +search yields the same elements.

+

For iterating from the front, the match_indices method can be used.

+

Examples

+

Basic usage:

+ +
+let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
+assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
+
+let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
+assert_eq!(v, [(4, "abc"), (1, "abc")]);
+
+let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
+assert_eq!(v, [(2, "aba")]); // only the last `aba`
+

#[must_use = + "this returns the trimmed string as a slice, \ + without modifying the original"]pub fn trim(&self) -> &str1.0.0[src]

Returns a string slice with leading and trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld", s.trim());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_start(&self) -> &str1.30.0[src]

Returns a string slice with leading whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. start in this context means the first +position of that byte string; for a left-to-right language like English or +Russian, this will be left side, and for right-to-left languages like +Arabic or Hebrew, this will be the right side.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+assert_eq!("Hello\tworld\t", s.trim_start());
+

Directionality:

+ +
+let s = "  English  ";
+assert!(Some('E') == s.trim_start().chars().next());
+
+let s = "  עברית  ";
+assert!(Some('ע') == s.trim_start().chars().next());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_end(&self) -> &str1.30.0[src]

Returns a string slice with trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. end in this context means the last +position of that byte string; for a left-to-right language like English or +Russian, this will be right side, and for right-to-left languages like +Arabic or Hebrew, this will be the left side.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+assert_eq!(" Hello\tworld", s.trim_end());
+

Directionality:

+ +
+let s = "  English  ";
+assert!(Some('h') == s.trim_end().chars().rev().next());
+
+let s = "  עברית  ";
+assert!(Some('ת') == s.trim_end().chars().rev().next());
+

pub fn trim_left(&self) -> &str1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_start

+

Returns a string slice with leading whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. 'Left' in this context means the first +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the right side, not the left.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld\t", s.trim_left());
+

Directionality:

+ +
+let s = "  English";
+assert!(Some('E') == s.trim_left().chars().next());
+
+let s = "  עברית";
+assert!(Some('ע') == s.trim_left().chars().next());
+

pub fn trim_right(&self) -> &str1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_end

+

Returns a string slice with trailing whitespace removed.

+

'Whitespace' is defined according to the terms of the Unicode Derived +Core Property White_Space.

+

Text directionality

+

A string is a sequence of bytes. 'Right' in this context means the last +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the left side, not the right.

+

Examples

+

Basic usage:

+ +
+let s = " Hello\tworld\t";
+
+assert_eq!(" Hello\tworld", s.trim_right());
+

Directionality:

+ +
+let s = "English  ";
+assert!(Some('h') == s.trim_right().chars().rev().next());
+
+let s = "עברית  ";
+assert!(Some('ת') == s.trim_right().chars().rev().next());
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>, 
1.0.0[src]

Returns a string slice with all prefixes and suffixes that match a +pattern repeatedly removed.

+

The pattern can be a char, a slice of chars, or a function +or closure that determines if a character matches.

+

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

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>, 
1.30.0[src]

Returns a string slice with all prefixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. start in this context means the first +position of that byte string; for a left-to-right language like English or +Russian, this will be left side, and for right-to-left languages like +Arabic or Hebrew, this will be the right side.

+

Examples

+

Basic usage:

+ +
+assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
+assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
+

#[must_use = + "this returns the remaining substring as a new slice, \ + without modifying the original"]pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str> where
    P: Pattern<'a>, 
1.45.0[src]

Returns a string slice with the prefix removed.

+

If the string starts with the pattern prefix, returns substring after the prefix, wrapped +in Some. Unlike trim_start_matches, this method removes the prefix exactly once.

+

If the string does not start with prefix, returns None.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
+assert_eq!("foo:bar".strip_prefix("bar"), None);
+assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
+

#[must_use = + "this returns the remaining substring as a new slice, \ + without modifying the original"]pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str> where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.45.0[src]

Returns a string slice with the suffix removed.

+

If the string ends with the pattern suffix, returns the substring before the suffix, +wrapped in Some. Unlike trim_end_matches, this method removes the suffix exactly once.

+

If the string does not end with suffix, returns None.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Examples

+
+assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
+assert_eq!("bar:foo".strip_suffix("bar"), None);
+assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
+

#[must_use = + "this returns the trimmed string as a new slice, \ + without modifying the original"]pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.30.0[src]

Returns a string slice with all suffixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. end in this context means the last +position of that byte string; for a left-to-right language like English or +Russian, this will be right side, and for right-to-left languages like +Arabic or Hebrew, this will be the left side.

+

Examples

+

Simple patterns:

+ +
+assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
+assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");
+

A more complex pattern, using a closure:

+ +
+assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
+

pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>, 
1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_start_matches

+

Returns a string slice with all prefixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. 'Left' in this context means the first +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the right side, not the left.

+

Examples

+

Basic usage:

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

pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where
    P: Pattern<'a>,
    <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 
1.0.0[src]

👎 Deprecated since 1.33.0:

superseded by trim_end_matches

+

Returns a string slice with all suffixes that match a pattern +repeatedly removed.

+

The pattern can be a &str, char, a slice of chars, or a +function or closure that determines if a character matches.

+

Text directionality

+

A string is a sequence of bytes. 'Right' in this context means the last +position of that byte string; for a language like Arabic or Hebrew +which are 'right to left' rather than 'left to right', this will be +the left side, not the right.

+

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_right_matches(|c| c == '1' || c == 'X'), "1foo");
+

pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err> where
    F: FromStr
1.0.0[src]

Parses this string slice into another type.

+

Because parse is so general, it can cause problems with type +inference. As such, parse is one of the few times you'll see +the syntax affectionately known as the 'turbofish': ::<>. This +helps the inference algorithm understand specifically which type +you're trying to parse into.

+

parse can parse into any type that implements the FromStr trait.

+

Errors

+

Will return Err if it's not possible to parse this string slice into +the desired type.

+

Examples

+

Basic usage

+ +
+let four: u32 = "4".parse().unwrap();
+
+assert_eq!(4, four);
+

Using the 'turbofish' instead of annotating four:

+ +
+let four = "4".parse::<u32>();
+
+assert_eq!(Ok(4), four);
+

Failing to parse:

+ +
+let nope = "j".parse::<u32>();
+
+assert!(nope.is_err());
+

pub fn is_ascii(&self) -> bool1.23.0[src]

Checks if all characters in this string are within the ASCII range.

+

Examples

+
+let ascii = "hello!\n";
+let non_ascii = "Grüße, Jürgen ❤";
+
+assert!(ascii.is_ascii());
+assert!(!non_ascii.is_ascii());
+

pub fn eq_ignore_ascii_case(&self, other: &str) -> bool1.23.0[src]

Checks that two strings are an ASCII case-insensitive match.

+

Same as to_ascii_lowercase(a) == to_ascii_lowercase(b), +but without allocating and copying temporaries.

+

Examples

+
+assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
+assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
+assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));
+

pub fn escape_debug(&self) -> EscapeDebug<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_debug.

+

Note: only extended grapheme codepoints that begin the string will be +escaped.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_debug() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_debug());
+

Both are equivalent to:

+ +
+println!("❤\\n!");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
+

pub fn escape_default(&self) -> EscapeDefault<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_default.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_default() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_default());
+

Both are equivalent to:

+ +
+println!("\\u{{2764}}\\n!");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
+

pub fn escape_unicode(&self) -> EscapeUnicode<'_>1.34.0[src]

Return an iterator that escapes each char in self with char::escape_unicode.

+

Examples

+

As an iterator:

+ +
+for c in "❤\n!".escape_unicode() {
+    print!("{}", c);
+}
+println!();
+

Using println! directly:

+ +
+println!("{}", "❤\n!".escape_unicode());
+

Both are equivalent to:

+ +
+println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
+

Using to_string:

+ +
+assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
+

#[must_use = + "this returns the replaced string as a new allocation, \ + without modifying the original"]pub fn replace<'a, P>(&'a self, from: P, to: &str) -> String where
    P: Pattern<'a>, 
1.0.0[src]

Replaces all matches of a pattern with another string.

+

replace creates a new String, and copies the data from this string slice into it. +While doing so, it attempts to find matches of a pattern. If it finds any, it +replaces them with the replacement string slice.

+

Examples

+

Basic usage:

+ +
+let s = "this is old";
+
+assert_eq!("this is new", s.replace("old", "new"));
+

When the pattern doesn't match:

+ +
+let s = "this is old";
+assert_eq!(s, s.replace("cookie monster", "little lamb"));
+

#[must_use = + "this returns the replaced string as a new allocation, \ + without modifying the original"]pub fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String where
    P: Pattern<'a>, 
1.16.0[src]

Replaces first N matches of a pattern with another string.

+

replacen creates a new String, and copies the data from this string slice into it. +While doing so, it attempts to find matches of a pattern. If it finds any, it +replaces them with the replacement string slice at most count times.

+

Examples

+

Basic usage:

+ +
+let s = "foo foo 123 foo";
+assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
+assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
+assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));
+

When the pattern doesn't match:

+ +
+let s = "this is old";
+assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
+

pub fn to_lowercase(&self) -> String1.2.0[src]

Returns the lowercase equivalent of this string slice, as a new String.

+

'Lowercase' is defined according to the terms of the Unicode Derived Core Property +Lowercase.

+

Since some characters can expand into multiple characters when changing +the case, this function returns a String instead of modifying the +parameter in-place.

+

Examples

+

Basic usage:

+ +
+let s = "HELLO";
+
+assert_eq!("hello", s.to_lowercase());
+

A tricky example, with sigma:

+ +
+let sigma = "Σ";
+
+assert_eq!("σ", sigma.to_lowercase());
+
+// but at the end of a word, it's ς, not σ:
+let odysseus = "ὈΔΥΣΣΕΎΣ";
+
+assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
+

Languages without case are not changed:

+ +
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_lowercase());
+

pub fn to_uppercase(&self) -> String1.2.0[src]

Returns the uppercase equivalent of this string slice, as a new String.

+

'Uppercase' is defined according to the terms of the Unicode Derived Core Property +Uppercase.

+

Since some characters can expand into multiple characters when changing +the case, this function returns a String instead of modifying the +parameter in-place.

+

Examples

+

Basic usage:

+ +
+let s = "hello";
+
+assert_eq!("HELLO", s.to_uppercase());
+

Scripts without case are not changed:

+ +
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_uppercase());
+

One character can become multiple:

+ +
+let s = "tschüß";
+
+assert_eq!("TSCHÜSS", s.to_uppercase());
+

pub fn repeat(&self, n: usize) -> String1.16.0[src]

Creates a new String by repeating a string n times.

+

Panics

+

This function will panic if the capacity would overflow.

+

Examples

+

Basic usage:

+ +
+assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
+

A panic upon overflow:

+ +
+// this will panic at runtime
+"0123456789abcdef".repeat(usize::MAX);
+

pub fn to_ascii_uppercase(&self) -> String1.23.0[src]

Returns a copy of this string where each character is mapped to its +ASCII upper case equivalent.

+

ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', +but non-ASCII letters are unchanged.

+

To uppercase the value in-place, use make_ascii_uppercase.

+

To uppercase ASCII characters in addition to non-ASCII characters, use +to_uppercase.

+

Examples

+
+let s = "Grüße, Jürgen ❤";
+
+assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
+

pub fn to_ascii_lowercase(&self) -> String1.23.0[src]

Returns a copy of this string where each character is mapped to its +ASCII lower case equivalent.

+

ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', +but non-ASCII letters are unchanged.

+

To lowercase the value in-place, use make_ascii_lowercase.

+

To lowercase ASCII characters in addition to non-ASCII characters, use +to_lowercase.

+

Examples

+
+let s = "Grüße, Jürgen ❤";
+
+assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
+

Trait Implementations

impl Deref for JS[src]

type Target = &'static str

The resulting type after dereferencing.

+

impl LazyStatic for JS[src]

Auto Trait Implementations

impl RefUnwindSafe for JS[src]

impl Send for JS[src]

impl Sync for JS[src]

impl Unpin for JS[src]

impl UnwindSafe for JS[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Conv for T

impl<T> Conv for T

impl<T> FmtForward for T

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pipe for T where
    T: ?Sized

impl<T> Pipe for T

impl<T> PipeAsRef for T

impl<T> PipeBorrow for T

impl<T> PipeDeref for T

impl<T> PipeRef for T

impl<T> Same<T> for T

type Output = T

Should always be Self

+

impl<T> Tap for T

impl<T> Tap for T

impl<T, U> TapAsRef<U> for T where
    U: ?Sized

impl<T, U> TapBorrow<U> for T where
    U: ?Sized

impl<T> TapDeref for T

impl<T> TryConv for T

impl<T> TryConv for T

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

+

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

+

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

+ \ No newline at end of file diff --git a/guard/struct.S.html b/guard/struct.S.html index cfda6d64..3ea7c7da 100644 --- a/guard/struct.S.html +++ b/guard/struct.S.html @@ -1,7 +1,7 @@ guard::S - Rust

Struct guard::S[][src]

pub struct S {
+                Change settings

Struct guard::S[][src]

pub struct S {
     __private_field: (),
 }

Fields

__private_field: ()

Methods from Deref<Target = String>

pub fn as_str(&self) -> &str1.7.0[src]

Extracts a string slice containing the entire String.

@@ -1442,9 +1442,9 @@ but non-ASCII letters are unchanged.

let s = "Grüße, Jürgen ❤"; assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
-

Trait Implementations

impl Deref for S[src]

type Target = String

The resulting type after dereferencing.

-

impl LazyStatic for S[src]

Auto Trait Implementations

impl RefUnwindSafe for S[src]

impl Send for S[src]

impl Sync for S[src]

impl Unpin for S[src]

impl UnwindSafe for S[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

Trait Implementations

impl Deref for S[src]

type Target = String

The resulting type after dereferencing.

+

impl LazyStatic for S[src]

Auto Trait Implementations

impl RefUnwindSafe for S[src]

impl Send for S[src]

impl Sync for S[src]

impl Unpin for S[src]

impl UnwindSafe for S[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Conv for T