From 94bd6007ac677fa81f44787fe88ce97776b1f5b4 Mon Sep 17 00:00:00 2001 From: realaravinth Date: Fri, 2 Apr 2021 15:23:26 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20=20@=20ecc00?= =?UTF-8?q?76cdda32988a2a47f092cebc9afb4968339=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- guard/all.html | 2 +- guard/fn.get_identity_service.html | 2 +- guard/fn.get_json_err.html | 2 +- guard/fn.main.html | 2 +- guard/index.html | 6 +- guard/sidebar-items.js | 2 +- guard/static.GIT_COMMIT_HASH.html | 5 + guard/static.OPEN_API_DOC.html | 5 + guard/static.PKG_DESCRIPTION.html | 2 +- guard/static.PKG_HOMEPAGE.html | 2 +- guard/static.PKG_NAME.html | 2 +- guard/static.VERIFICATION_PATH.html | 2 +- guard/static.VERSION.html | 2 +- guard/struct.GIT_COMMIT_HASH.html | 1555 ----------------- guard/struct.OPEN_API_DOC.html | 1555 ----------------- guard/struct.S.html | 8 +- guard/struct.SETTINGS.html | 8 +- implementors/core/marker/trait.Freeze.js | 2 +- implementors/core/marker/trait.Send.js | 2 +- implementors/core/marker/trait.Sync.js | 2 +- implementors/core/marker/trait.Unpin.js | 2 +- implementors/core/ops/deref/trait.Deref.js | 2 +- implementors/lazy_static/trait.LazyStatic.js | 2 +- implementors/std/panic/trait.RefUnwindSafe.js | 2 +- implementors/std/panic/trait.UnwindSafe.js | 2 +- search-index.js | 2 +- src/guard/main.rs.html | 14 +- 27 files changed, 50 insertions(+), 3144 deletions(-) create mode 100644 guard/static.GIT_COMMIT_HASH.html create mode 100644 guard/static.OPEN_API_DOC.html delete mode 100644 guard/struct.GIT_COMMIT_HASH.html delete mode 100644 guard/struct.OPEN_API_DOC.html diff --git a/guard/all.html b/guard/all.html index 055ecaf2..a50017bb 100644 --- a/guard/all.html +++ b/guard/all.html @@ -3,5 +3,5 @@

List of all items[−] -

Structs

Enums

Functions

Typedefs

Statics

+

Structs

Enums

Functions

Typedefs

Statics

\ No newline at end of file diff --git a/guard/fn.get_identity_service.html b/guard/fn.get_identity_service.html index ae07e7d4..91ff13ca 100644 --- a/guard/fn.get_identity_service.html +++ b/guard/fn.get_identity_service.html @@ -1,5 +1,5 @@ guard::get_identity_service - Rust

Function guard::get_identity_service[−][src]

pub fn get_identity_service() -> IdentityService<CookieIdentityPolicy>
+ Change settings

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 537c4ccc..dbdbed06 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 f1a1ca2a..a43dac8d 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 83568f6c..6765f069 100644 --- a/guard/index.html +++ b/guard/index.html @@ -1,9 +1,9 @@ guard - Rust

Crate guard[−][src]

Modules

+ Change settings

Crate guard[−][src]

Modules

api
data
docs
errors
settings

Structs

-
Data
GIT_COMMIT_HASH
OPEN_API_DOC
S
SETTINGS
Settings

Statics

-
PKG_DESCRIPTION
PKG_HOMEPAGE
PKG_NAME
VERIFICATION_PATH
VERSION

Functions

+
Data
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 5eb4b05c..855e75b9 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":[["PKG_DESCRIPTION",""],["PKG_HOMEPAGE",""],["PKG_NAME",""],["VERIFICATION_PATH",""],["VERSION",""]],"struct":[["Data",""],["GIT_COMMIT_HASH",""],["OPEN_API_DOC",""],["S",""],["SETTINGS",""],["Settings",""]]}); \ No newline at end of file +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 diff --git a/guard/static.GIT_COMMIT_HASH.html b/guard/static.GIT_COMMIT_HASH.html new file mode 100644 index 00000000..4e4f0fd8 --- /dev/null +++ b/guard/static.GIT_COMMIT_HASH.html @@ -0,0 +1,5 @@ +guard::GIT_COMMIT_HASH - Rust + +

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 new file mode 100644 index 00000000..ef12d7fd --- /dev/null +++ b/guard/static.OPEN_API_DOC.html @@ -0,0 +1,5 @@ +guard::OPEN_API_DOC - Rust + +

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 aaaafff8..a3606eb4 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 37832cb7..70f8d54f 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 31073c00..1372a69e 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 f695a047..f595d145 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 53bf7504..34601e94 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.GIT_COMMIT_HASH.html b/guard/struct.GIT_COMMIT_HASH.html deleted file mode 100644 index a4a85c6f..00000000 --- a/guard/struct.GIT_COMMIT_HASH.html +++ /dev/null @@ -1,1555 +0,0 @@ -guard::GIT_COMMIT_HASH - Rust - -

Struct guard::GIT_COMMIT_HASH[−][src]

pub struct GIT_COMMIT_HASH {
-    __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.

-

Examples

-

Basic usage:

- -
-let s = String::from("foo");
-
-assert_eq!("foo", s.as_str());
-

pub fn capacity(&self) -> usize1.0.0[src]

Returns this String's capacity, in bytes.

-

Examples

-

Basic usage:

- -
-let s = String::with_capacity(10);
-
-assert!(s.capacity() >= 10);
-

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

Returns a byte slice of this String's contents.

-

The inverse of this method is from_utf8.

-

Examples

-

Basic usage:

- -
-let s = String::from("hello");
-
-assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

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

Returns the length of this String, 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 a = String::from("foo");
-assert_eq!(a.len(), 3);
-
-let fancy_f = String::from("ƒoo");
-assert_eq!(fancy_f.len(), 4);
-assert_eq!(fancy_f.chars().count(), 3);
-

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

Returns true if this String has a length of zero, and false otherwise.

-

Examples

-

Basic usage:

- -
-let mut v = String::new();
-assert!(v.is_empty());
-
-v.push('a');
-assert!(!v.is_empty());
-

Methods from Deref<Target = 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 unsafe fn as_bytes_mut(&mut self) -> &mut [u8]1.20.0[src]

Converts a mutable string slice to a mutable byte slice.

-

Safety

-

The caller must ensure that the content of the slice is valid UTF-8 -before the borrow ends and the underlying str is used.

-

Use of a str whose contents are not valid UTF-8 is undefined behavior.

-

Examples

-

Basic usage:

- -
-let mut s = String::from("Hello");
-let bytes = unsafe { s.as_bytes_mut() };
-
-assert_eq!(b"Hello", bytes);
-

Mutability:

- -
-let mut s = String::from("🗻∈🌏");
-
-unsafe {
-    let bytes = s.as_bytes_mut();
-
-    bytes[0] = 0xF0;
-    bytes[1] = 0x9F;
-    bytes[2] = 0x8D;
-    bytes[3] = 0x94;
-}
-
-assert_eq!("🍔∈🌏", s);
-

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 as_mut_ptr(&mut self) -> *mut u81.36.0[src]

Converts a mutable 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.

-

It is your responsibility to make sure that the string slice only gets -modified in a way that it remains valid UTF-8.

-

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 fn get_mut<I>(
    &mut self,
    i: I
) -> Option<&mut <I as SliceIndex<str>>::Output> where
    I: SliceIndex<str>, 1.20.0[src]

Returns a mutable subslice of str.

-

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

-

Examples

-
-let mut v = String::from("hello");
-// correct length
-assert!(v.get_mut(0..5).is_some());
-// out of bounds
-assert!(v.get_mut(..42).is_none());
-assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));
-
-assert_eq!("hello", v);
-{
-    let s = v.get_mut(0..2);
-    let s = s.map(|s| {
-        s.make_ascii_uppercase();
-        &*s
-    });
-    assert_eq!(Some("HE"), s);
-}
-assert_eq!("HEllo", v);
-

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 get_unchecked_mut<I>(
    &mut self,
    i: I
) -> &mut <I as SliceIndex<str>>::Output where
    I: SliceIndex<str>, 1.20.0[src]

Returns a mutable, 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 mut v = String::from("🗻∈🌏");
-unsafe {
-    assert_eq!("🗻", v.get_unchecked_mut(0..4));
-    assert_eq!("∈", v.get_unchecked_mut(4..7));
-    assert_eq!("🌏", v.get_unchecked_mut(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 unsafe fn slice_mut_unchecked(
    &mut self,
    begin: usize,
    end: usize
) -> &mut str1.5.0[src]

👎 Deprecated since 1.29.0:

use get_unchecked_mut(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 IndexMut.

-

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

-

To get an immutable string slice instead, see the -slice_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.
    • -
-

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 split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)1.4.0[src]

Divide one mutable 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 immutable string slices instead, see the split_at 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 mut s = "Per Martin-Löf".to_string();
-{
-    let (first, last) = s.split_at_mut(3);
-    first.make_ascii_uppercase();
-    assert_eq!("PER", first);
-    assert_eq!(" Martin-Löf", last);
-}
-assert_eq!("PER Martin-Löf", s);
-

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 make_ascii_uppercase(&mut self)1.23.0[src]

Converts this string to its ASCII upper case equivalent in-place.

-

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

-

To return a new uppercased value without modifying the existing one, use -to_ascii_uppercase().

-

Examples

-
-let mut s = String::from("Grüße, Jürgen ❤");
-
-s.make_ascii_uppercase();
-
-assert_eq!("GRüßE, JüRGEN ❤", s);
-

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

Converts this string to its ASCII lower case equivalent in-place.

-

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

-

To return a new lowercased value without modifying the existing one, use -to_ascii_lowercase().

-

Examples

-
-let mut s = String::from("GRÜßE, JÜRGEN ❤");
-
-s.make_ascii_lowercase();
-
-assert_eq!("grÜße, jÜrgen ❤", 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 GIT_COMMIT_HASH[src]

type Target = String

The resulting type after dereferencing.

-

impl LazyStatic for GIT_COMMIT_HASH[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.OPEN_API_DOC.html b/guard/struct.OPEN_API_DOC.html deleted file mode 100644 index f2708ccc..00000000 --- a/guard/struct.OPEN_API_DOC.html +++ /dev/null @@ -1,1555 +0,0 @@ -guard::OPEN_API_DOC - Rust - -

Struct guard::OPEN_API_DOC[−][src]

pub struct OPEN_API_DOC {
-    __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.

-

Examples

-

Basic usage:

- -
-let s = String::from("foo");
-
-assert_eq!("foo", s.as_str());
-

pub fn capacity(&self) -> usize1.0.0[src]

Returns this String's capacity, in bytes.

-

Examples

-

Basic usage:

- -
-let s = String::with_capacity(10);
-
-assert!(s.capacity() >= 10);
-

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

Returns a byte slice of this String's contents.

-

The inverse of this method is from_utf8.

-

Examples

-

Basic usage:

- -
-let s = String::from("hello");
-
-assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

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

Returns the length of this String, 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 a = String::from("foo");
-assert_eq!(a.len(), 3);
-
-let fancy_f = String::from("ƒoo");
-assert_eq!(fancy_f.len(), 4);
-assert_eq!(fancy_f.chars().count(), 3);
-

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

Returns true if this String has a length of zero, and false otherwise.

-

Examples

-

Basic usage:

- -
-let mut v = String::new();
-assert!(v.is_empty());
-
-v.push('a');
-assert!(!v.is_empty());
-

Methods from Deref<Target = 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 unsafe fn as_bytes_mut(&mut self) -> &mut [u8]1.20.0[src]

Converts a mutable string slice to a mutable byte slice.

-

Safety

-

The caller must ensure that the content of the slice is valid UTF-8 -before the borrow ends and the underlying str is used.

-

Use of a str whose contents are not valid UTF-8 is undefined behavior.

-

Examples

-

Basic usage:

- -
-let mut s = String::from("Hello");
-let bytes = unsafe { s.as_bytes_mut() };
-
-assert_eq!(b"Hello", bytes);
-

Mutability:

- -
-let mut s = String::from("🗻∈🌏");
-
-unsafe {
-    let bytes = s.as_bytes_mut();
-
-    bytes[0] = 0xF0;
-    bytes[1] = 0x9F;
-    bytes[2] = 0x8D;
-    bytes[3] = 0x94;
-}
-
-assert_eq!("🍔∈🌏", s);
-

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 as_mut_ptr(&mut self) -> *mut u81.36.0[src]

Converts a mutable 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.

-

It is your responsibility to make sure that the string slice only gets -modified in a way that it remains valid UTF-8.

-

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 fn get_mut<I>(
    &mut self,
    i: I
) -> Option<&mut <I as SliceIndex<str>>::Output> where
    I: SliceIndex<str>, 1.20.0[src]

Returns a mutable subslice of str.

-

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

-

Examples

-
-let mut v = String::from("hello");
-// correct length
-assert!(v.get_mut(0..5).is_some());
-// out of bounds
-assert!(v.get_mut(..42).is_none());
-assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));
-
-assert_eq!("hello", v);
-{
-    let s = v.get_mut(0..2);
-    let s = s.map(|s| {
-        s.make_ascii_uppercase();
-        &*s
-    });
-    assert_eq!(Some("HE"), s);
-}
-assert_eq!("HEllo", v);
-

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 get_unchecked_mut<I>(
    &mut self,
    i: I
) -> &mut <I as SliceIndex<str>>::Output where
    I: SliceIndex<str>, 1.20.0[src]

Returns a mutable, 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 mut v = String::from("🗻∈🌏");
-unsafe {
-    assert_eq!("🗻", v.get_unchecked_mut(0..4));
-    assert_eq!("∈", v.get_unchecked_mut(4..7));
-    assert_eq!("🌏", v.get_unchecked_mut(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 unsafe fn slice_mut_unchecked(
    &mut self,
    begin: usize,
    end: usize
) -> &mut str1.5.0[src]

👎 Deprecated since 1.29.0:

use get_unchecked_mut(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 IndexMut.

-

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

-

To get an immutable string slice instead, see the -slice_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.
    • -
-

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 split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)1.4.0[src]

Divide one mutable 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 immutable string slices instead, see the split_at 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 mut s = "Per Martin-Löf".to_string();
-{
-    let (first, last) = s.split_at_mut(3);
-    first.make_ascii_uppercase();
-    assert_eq!("PER", first);
-    assert_eq!(" Martin-Löf", last);
-}
-assert_eq!("PER Martin-Löf", s);
-

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 make_ascii_uppercase(&mut self)1.23.0[src]

Converts this string to its ASCII upper case equivalent in-place.

-

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

-

To return a new uppercased value without modifying the existing one, use -to_ascii_uppercase().

-

Examples

-
-let mut s = String::from("Grüße, Jürgen ❤");
-
-s.make_ascii_uppercase();
-
-assert_eq!("GRüßE, JüRGEN ❤", s);
-

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

Converts this string to its ASCII lower case equivalent in-place.

-

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

-

To return a new lowercased value without modifying the existing one, use -to_ascii_lowercase().

-

Examples

-
-let mut s = String::from("GRÜßE, JÜRGEN ❤");
-
-s.make_ascii_lowercase();
-
-assert_eq!("grÜße, jÜrgen ❤", 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 OPEN_API_DOC[src]

type Target = String

The resulting type after dereferencing.

-

impl LazyStatic for OPEN_API_DOC[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.S.html b/guard/struct.S.html index c0b1effb..cfda6d64 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