Type Alias wasmer_cli::c_gen::CIdent

source ·
pub type CIdent = String;
Expand description

An identifier in C.

Aliased Type§

struct CIdent { /* private fields */ }

Implementations

source§

impl String

1.0.0 (const: 1.39.0) · source

pub const fn new() -> String

Creates a new empty String.

Given that the String is empty, this will not allocate any initial buffer. While that means that this initial operation is very inexpensive, it may cause excessive allocation later when you add data. If you have an idea of how much data the String will hold, consider the with_capacity method to prevent excessive re-allocation.

§Examples
let s = String::new();
1.0.0 · source

pub fn with_capacity(capacity: usize) -> String

Creates a new empty String with at least the specified capacity.

Strings have an internal buffer to hold their data. The capacity is the length of that buffer, and can be queried with the capacity method. This method creates an empty String, but one with an initial buffer that can hold at least capacity bytes. This is useful when you may be appending a bunch of data to the String, reducing the number of reallocations it needs to do.

If the given capacity is 0, no allocation will occur, and this method is identical to the new method.

§Examples
let mut s = String::with_capacity(10);

// The String contains no chars, even though it has capacity for more
assert_eq!(s.len(), 0);

// These are all done without reallocating...
let cap = s.capacity();
for _ in 0..10 {
    s.push('a');
}

assert_eq!(s.capacity(), cap);

// ...but this may make the string reallocate
s.push('a');
source

pub fn try_with_capacity(capacity: usize) -> Result<String, TryReserveError>

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

Creates a new empty String with at least the specified capacity.

§Errors

Returns Err if the capacity exceeds isize::MAX bytes, or if the memory allocator reports failure.

1.0.0 · source

pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>

Converts a vector of bytes to a String.

A string (String) is made of bytes (u8), and a vector of bytes (Vec<u8>) is made of bytes, so this function converts between the two. Not all byte slices are valid Strings, however: String requires that it is valid UTF-8. from_utf8() checks to ensure that the bytes are valid UTF-8, and then does the conversion.

If you are sure that the byte slice is valid UTF-8, and you don’t want to incur the overhead of the validity check, there is an unsafe version of this function, from_utf8_unchecked, which has the same behavior but skips the check.

This method will take care to not copy the vector, for efficiency’s sake.

If you need a &str instead of a String, consider str::from_utf8.

The inverse of this method is into_bytes.

§Errors

Returns Err if the slice is not UTF-8 with a description as to why the provided bytes are not UTF-8. The vector you moved in is also included.

§Examples

Basic usage:

// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

// We know these bytes are valid, so we'll use `unwrap()`.
let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();

assert_eq!("💖", sparkle_heart);

Incorrect bytes:

// some invalid bytes, in a vector
let sparkle_heart = vec![0, 159, 146, 150];

assert!(String::from_utf8(sparkle_heart).is_err());

See the docs for FromUtf8Error for more details on what you can do with this error.

1.0.0 · source

pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>

Converts a slice of bytes to a string, including invalid characters.

Strings are made of bytes (u8), and a slice of bytes (&[u8]) is made of bytes, so this function converts between the two. Not all byte slices are valid strings, however: strings are required to be valid UTF-8. During this conversion, from_utf8_lossy() will replace any invalid UTF-8 sequences with U+FFFD REPLACEMENT CHARACTER, which looks like this: �

If you are sure that the byte slice is valid UTF-8, and you don’t want to incur the overhead of the conversion, there is an unsafe version of this function, from_utf8_unchecked, which has the same behavior but skips the checks.

This function returns a Cow<'a, str>. If our byte slice is invalid UTF-8, then we need to insert the replacement characters, which will change the size of the string, and hence, require a String. But if it’s already valid UTF-8, we don’t need a new allocation. This return type allows us to handle both cases.

§Examples

Basic usage:

// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);

assert_eq!("💖", sparkle_heart);

Incorrect bytes:

// some invalid bytes
let input = b"Hello \xF0\x90\x80World";
let output = String::from_utf8_lossy(input);

assert_eq!("Hello �World", output);
1.0.0 · source

pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>

Decode a UTF-16–encoded vector v into a String, returning Err if v contains any invalid data.

§Examples
// 𝄞music
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0x0073, 0x0069, 0x0063];
assert_eq!(String::from("𝄞music"),
           String::from_utf16(v).unwrap());

// 𝄞mu<invalid>ic
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0xD800, 0x0069, 0x0063];
assert!(String::from_utf16(v).is_err());
1.0.0 · source

pub fn from_utf16_lossy(v: &[u16]) -> String

Decode a UTF-16–encoded slice v into a String, replacing invalid data with the replacement character (U+FFFD).

Unlike from_utf8_lossy which returns a Cow<'a, str>, from_utf16_lossy returns a String since the UTF-16 to UTF-8 conversion requires a memory allocation.

§Examples
// 𝄞mus<invalid>ic<invalid>
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0x0073, 0xDD1E, 0x0069, 0x0063,
          0xD834];

assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
           String::from_utf16_lossy(v));
source

pub fn from_utf16le(v: &[u8]) -> Result<String, FromUtf16Error>

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

Decode a UTF-16LE–encoded vector v into a String, returning Err if v contains any invalid data.

§Examples

Basic usage:

#![feature(str_from_utf16_endian)]
// 𝄞music
let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
          0x73, 0x00, 0x69, 0x00, 0x63, 0x00];
assert_eq!(String::from("𝄞music"),
           String::from_utf16le(v).unwrap());

// 𝄞mu<invalid>ic
let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
          0x00, 0xD8, 0x69, 0x00, 0x63, 0x00];
assert!(String::from_utf16le(v).is_err());
source

pub fn from_utf16le_lossy(v: &[u8]) -> String

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

Decode a UTF-16LE–encoded slice v into a String, replacing invalid data with the replacement character (U+FFFD).

Unlike from_utf8_lossy which returns a Cow<'a, str>, from_utf16le_lossy returns a String since the UTF-16 to UTF-8 conversion requires a memory allocation.

§Examples

Basic usage:

#![feature(str_from_utf16_endian)]
// 𝄞mus<invalid>ic<invalid>
let v = &[0x34, 0xD8, 0x1E, 0xDD, 0x6d, 0x00, 0x75, 0x00,
          0x73, 0x00, 0x1E, 0xDD, 0x69, 0x00, 0x63, 0x00,
          0x34, 0xD8];

assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
           String::from_utf16le_lossy(v));
source

pub fn from_utf16be(v: &[u8]) -> Result<String, FromUtf16Error>

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

Decode a UTF-16BE–encoded vector v into a String, returning Err if v contains any invalid data.

§Examples

Basic usage:

#![feature(str_from_utf16_endian)]
// 𝄞music
let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
          0x00, 0x73, 0x00, 0x69, 0x00, 0x63];
assert_eq!(String::from("𝄞music"),
           String::from_utf16be(v).unwrap());

// 𝄞mu<invalid>ic
let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
          0xD8, 0x00, 0x00, 0x69, 0x00, 0x63];
assert!(String::from_utf16be(v).is_err());
source

pub fn from_utf16be_lossy(v: &[u8]) -> String

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

Decode a UTF-16BE–encoded slice v into a String, replacing invalid data with the replacement character (U+FFFD).

Unlike from_utf8_lossy which returns a Cow<'a, str>, from_utf16le_lossy returns a String since the UTF-16 to UTF-8 conversion requires a memory allocation.

§Examples

Basic usage:

#![feature(str_from_utf16_endian)]
// 𝄞mus<invalid>ic<invalid>
let v = &[0xD8, 0x34, 0xDD, 0x1E, 0x00, 0x6d, 0x00, 0x75,
          0x00, 0x73, 0xDD, 0x1E, 0x00, 0x69, 0x00, 0x63,
          0xD8, 0x34];

assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
           String::from_utf16be_lossy(v));
source

pub fn into_raw_parts(self) -> (*mut u8, usize, usize)

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

Decomposes a String into its raw components: (pointer, length, capacity).

Returns the raw pointer to the underlying data, the length of the string (in bytes), and the allocated capacity of the data (in bytes). These are the same arguments in the same order as the arguments to from_raw_parts.

After calling this function, the caller is responsible for the memory previously managed by the String. The only way to do this is to convert the raw pointer, length, and capacity back into a String with the from_raw_parts function, allowing the destructor to perform the cleanup.

§Examples
#![feature(vec_into_raw_parts)]
let s = String::from("hello");

let (ptr, len, cap) = s.into_raw_parts();

let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
assert_eq!(rebuilt, "hello");
1.0.0 · source

pub unsafe fn from_raw_parts( buf: *mut u8, length: usize, capacity: usize, ) -> String

Creates a new String from a pointer, a length and a capacity.

§Safety

This is highly unsafe, due to the number of invariants that aren’t checked:

  • The memory at buf needs to have been previously allocated by the same allocator the standard library uses, with a required alignment of exactly 1.
  • length needs to be less than or equal to capacity.
  • capacity needs to be the correct value.
  • The first length bytes at buf need to be valid UTF-8.

Violating these may cause problems like corrupting the allocator’s internal data structures. For example, it is normally not safe to build a String from a pointer to a C char array containing UTF-8 unless you are certain that array was originally allocated by the Rust standard library’s allocator.

The ownership of buf is effectively transferred to the String which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.

§Examples
use std::mem;

unsafe {
    let s = String::from("hello");

    // Prevent automatically dropping the String's data
    let mut s = mem::ManuallyDrop::new(s);

    let ptr = s.as_mut_ptr();
    let len = s.len();
    let capacity = s.capacity();

    let s = String::from_raw_parts(ptr, len, capacity);

    assert_eq!(String::from("hello"), s);
}
1.0.0 · source

pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String

Converts a vector of bytes to a String without checking that the string contains valid UTF-8.

See the safe version, from_utf8, for more details.

§Safety

This function is unsafe because it does not check that the bytes passed to it are valid UTF-8. If this constraint is violated, it may cause memory unsafety issues with future users of the String, as the rest of the standard library assumes that Strings are valid UTF-8.

§Examples
// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = unsafe {
    String::from_utf8_unchecked(sparkle_heart)
};

assert_eq!("💖", sparkle_heart);
1.0.0 · source

pub fn into_bytes(self) -> Vec<u8>

Converts a String into a byte vector.

This consumes the String, so we do not need to copy its contents.

§Examples
let s = String::from("hello");
let bytes = s.into_bytes();

assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);
1.7.0 · source

pub fn as_str(&self) -> &str

Extracts a string slice containing the entire String.

§Examples
let s = String::from("foo");

assert_eq!("foo", s.as_str());
1.7.0 · source

pub fn as_mut_str(&mut self) -> &mut str

Converts a String into a mutable string slice.

§Examples
let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str();

s_mut_str.make_ascii_uppercase();

assert_eq!("FOOBAR", s_mut_str);
1.0.0 · source

pub fn push_str(&mut self, string: &str)

Appends a given string slice onto the end of this String.

§Examples
let mut s = String::from("foo");

s.push_str("bar");

assert_eq!("foobar", s);
source

pub fn extend_from_within<R>(&mut self, src: R)
where R: RangeBounds<usize>,

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

Copies elements from src range to the end of the string.

§Panics

Panics if the starting point or end point do not lie on a char boundary, or if they’re out of bounds.

§Examples
#![feature(string_extend_from_within)]
let mut string = String::from("abcde");

string.extend_from_within(2..);
assert_eq!(string, "abcdecde");

string.extend_from_within(..2);
assert_eq!(string, "abcdecdeab");

string.extend_from_within(4..8);
assert_eq!(string, "abcdecdeabecde");
1.0.0 · source

pub fn capacity(&self) -> usize

Returns this String’s capacity, in bytes.

§Examples
let s = String::with_capacity(10);

assert!(s.capacity() >= 10);
1.0.0 · source

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional bytes more than the current length. The allocator may reserve more space to speculatively avoid frequent allocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

§Panics

Panics if the new capacity overflows usize.

§Examples

Basic usage:

let mut s = String::new();

s.reserve(10);

assert!(s.capacity() >= 10);

This might not actually increase the capacity:

let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s now has a length of 2 and a capacity of at least 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// Since we already have at least an extra 8 capacity, calling this...
s.reserve(8);

// ... doesn't actually increase.
assert_eq!(capacity, s.capacity());
1.0.0 · source

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for at least additional bytes more than the current length. Unlike reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

§Panics

Panics if the new capacity overflows usize.

§Examples

Basic usage:

let mut s = String::new();

s.reserve_exact(10);

assert!(s.capacity() >= 10);

This might not actually increase the capacity:

let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s now has a length of 2 and a capacity of at least 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// Since we already have at least an extra 8 capacity, calling this...
s.reserve_exact(8);

// ... doesn't actually increase.
assert_eq!(capacity, s.capacity());
1.57.0 · source

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Tries to reserve capacity for at least additional bytes more than the current length. The allocator may reserve more space to speculatively avoid frequent allocations. After calling try_reserve, capacity will be greater than or equal to self.len() + additional if it returns Ok(()). Does nothing if capacity is already sufficient. This method preserves the contents even if an error occurs.

§Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

§Examples
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
1.57.0 · source

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Tries to reserve the minimum capacity for at least additional bytes more than the current length. Unlike try_reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling try_reserve_exact, capacity will be greater than or equal to self.len() + additional if it returns Ok(()). Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer try_reserve if future insertions are expected.

§Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

§Examples
use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // Pre-reserve the memory, exiting if we can't
    output.try_reserve_exact(data.len())?;

    // Now we know this can't OOM in the middle of our complex work
    output.push_str(data);

    Ok(output)
}
1.0.0 · source

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of this String to match its length.

§Examples
let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());
1.56.0 · source

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of this String with a lower bound.

The capacity will remain at least as large as both the length and the supplied value.

If the current capacity is less than the lower limit, this is a no-op.

§Examples
let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to(10);
assert!(s.capacity() >= 10);
s.shrink_to(0);
assert!(s.capacity() >= 3);
1.0.0 · source

pub fn push(&mut self, ch: char)

Appends the given char to the end of this String.

§Examples
let mut s = String::from("abc");

s.push('1');
s.push('2');
s.push('3');

assert_eq!("abc123", s);
1.0.0 · source

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

Returns a byte slice of this String’s contents.

The inverse of this method is from_utf8.

§Examples
let s = String::from("hello");

assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
1.0.0 · source

pub fn truncate(&mut self, new_len: usize)

Shortens this String to the specified length.

If new_len is greater than or equal to the string’s current length, this has no effect.

Note that this method has no effect on the allocated capacity of the string

§Panics

Panics if new_len does not lie on a char boundary.

§Examples
let mut s = String::from("hello");

s.truncate(2);

assert_eq!("he", s);
1.0.0 · source

pub fn pop(&mut self) -> Option<char>

Removes the last character from the string buffer and returns it.

Returns None if this String is empty.

§Examples
let mut s = String::from("abč");

assert_eq!(s.pop(), Some('č'));
assert_eq!(s.pop(), Some('b'));
assert_eq!(s.pop(), Some('a'));

assert_eq!(s.pop(), None);
1.0.0 · source

pub fn remove(&mut self, idx: usize) -> char

Removes a char from this String at a byte position and returns it.

This is an O(n) operation, as it requires copying every element in the buffer.

§Panics

Panics if idx is larger than or equal to the String’s length, or if it does not lie on a char boundary.

§Examples
let mut s = String::from("abç");

assert_eq!(s.remove(0), 'a');
assert_eq!(s.remove(1), 'ç');
assert_eq!(s.remove(0), 'b');
source

pub fn remove_matches<'a, P>(&'a mut self, pat: P)
where P: for<'x> Pattern<'x>,

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

Remove all matches of pattern pat in the String.

§Examples
#![feature(string_remove_matches)]
let mut s = String::from("Trees are not green, the sky is not blue.");
s.remove_matches("not ");
assert_eq!("Trees are green, the sky is blue.", s);

Matches will be detected and removed iteratively, so in cases where patterns overlap, only the first pattern will be removed:

#![feature(string_remove_matches)]
let mut s = String::from("banana");
s.remove_matches("ana");
assert_eq!("bna", s);
1.26.0 · source

pub fn retain<F>(&mut self, f: F)
where F: FnMut(char) -> bool,

Retains only the characters specified by the predicate.

In other words, remove all characters c such that f(c) returns false. This method operates in place, visiting each character exactly once in the original order, and preserves the order of the retained characters.

§Examples
let mut s = String::from("f_o_ob_ar");

s.retain(|c| c != '_');

assert_eq!(s, "foobar");

Because the elements are visited exactly once in the original order, external state may be used to decide which elements to keep.

let mut s = String::from("abcde");
let keep = [false, true, true, false, true];
let mut iter = keep.iter();
s.retain(|_| *iter.next().unwrap());
assert_eq!(s, "bce");
1.0.0 · source

pub fn insert(&mut self, idx: usize, ch: char)

Inserts a character into this String at a byte position.

This is an O(n) operation as it requires copying every element in the buffer.

§Panics

Panics if idx is larger than the String’s length, or if it does not lie on a char boundary.

§Examples
let mut s = String::with_capacity(3);

s.insert(0, 'f');
s.insert(1, 'o');
s.insert(2, 'o');

assert_eq!("foo", s);
1.16.0 · source

pub fn insert_str(&mut self, idx: usize, string: &str)

Inserts a string slice into this String at a byte position.

This is an O(n) operation as it requires copying every element in the buffer.

§Panics

Panics if idx is larger than the String’s length, or if it does not lie on a char boundary.

§Examples
let mut s = String::from("bar");

s.insert_str(0, "foo");

assert_eq!("foobar", s);
1.0.0 · source

pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>

Returns a mutable reference to the contents of this String.

§Safety

This function is unsafe because the returned &mut Vec allows writing bytes which are not valid UTF-8. If this constraint is violated, using the original String after dropping the &mut Vec may violate memory safety, as the rest of the standard library assumes that Strings are valid UTF-8.

§Examples
let mut s = String::from("hello");

unsafe {
    let vec = s.as_mut_vec();
    assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);

    vec.reverse();
}
assert_eq!(s, "olleh");
1.0.0 · source

pub fn len(&self) -> usize

Returns the length of this String, in bytes, not chars or graphemes. In other words, it might not be what a human considers the length of the string.

§Examples
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);
1.0.0 · source

pub fn is_empty(&self) -> bool

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

§Examples
let mut v = String::new();
assert!(v.is_empty());

v.push('a');
assert!(!v.is_empty());
1.16.0 · source

pub fn split_off(&mut self, at: usize) -> String

Splits the string into two at the given byte index.

Returns a newly allocated String. self contains bytes [0, at), and the returned String contains bytes [at, len). at must be on the boundary of a UTF-8 code point.

Note that the capacity of self does not change.

§Panics

Panics if at is not on a UTF-8 code point boundary, or if it is beyond the last code point of the string.

§Examples
let mut hello = String::from("Hello, World!");
let world = hello.split_off(7);
assert_eq!(hello, "Hello, ");
assert_eq!(world, "World!");
1.0.0 · source

pub fn clear(&mut self)

Truncates this String, removing all contents.

While this means the String will have a length of zero, it does not touch its capacity.

§Examples
let mut s = String::from("foo");

s.clear();

assert!(s.is_empty());
assert_eq!(0, s.len());
assert_eq!(3, s.capacity());
1.6.0 · source

pub fn drain<R>(&mut self, range: R) -> Drain<'_>
where R: RangeBounds<usize>,

Removes the specified range from the string in bulk, returning all removed characters as an iterator.

The returned iterator keeps a mutable borrow on the string to optimize its implementation.

§Panics

Panics if the starting point or end point do not lie on a char boundary, or if they’re out of bounds.

§Leaking

If the returned iterator goes out of scope without being dropped (due to core::mem::forget, for example), the string may still contain a copy of any drained characters, or may have lost characters arbitrarily, including characters outside the range.

§Examples
let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// Remove the range up until the β from the string
let t: String = s.drain(..beta_offset).collect();
assert_eq!(t, "α is alpha, ");
assert_eq!(s, "β is beta");

// A full range clears the string, like `clear()` does
s.drain(..);
assert_eq!(s, "");
1.27.0 · source

pub fn replace_range<R>(&mut self, range: R, replace_with: &str)
where R: RangeBounds<usize>,

Removes the specified range in the string, and replaces it with the given string. The given string doesn’t need to be the same length as the range.

§Panics

Panics if the starting point or end point do not lie on a char boundary, or if they’re out of bounds.

§Examples
let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// Replace the range up until the β from the string
s.replace_range(..beta_offset, "Α is capital alpha; ");
assert_eq!(s, "Α is capital alpha; β is beta");
1.4.0 · source

pub fn into_boxed_str(self) -> Box<str>

Converts this String into a Box<str>.

Before doing the conversion, this method discards excess capacity like shrink_to_fit. Note that this call may reallocate and copy the bytes of the string.

§Examples
let s = String::from("hello");

let b = s.into_boxed_str();
1.72.0 · source

pub fn leak<'a>(self) -> &'a mut str

Consumes and leaks the String, returning a mutable reference to the contents, &'a mut str.

The caller has free choice over the returned lifetime, including 'static. Indeed, this function is ideally used for data that lives for the remainder of the program’s life, as dropping the returned reference will cause a memory leak.

It does not reallocate or shrink the String, so the leaked allocation may include unused capacity that is not part of the returned slice. If you want to discard excess capacity, call into_boxed_str, and then Box::leak instead. However, keep in mind that trimming the capacity may result in a reallocation and copy.

§Examples
let x = String::from("bucket");
let static_ref: &'static mut str = x.leak();
assert_eq!(static_ref, "bucket");

Trait Implementations

§

impl<'i> Accumulate<&'i str> for String

§

fn initial(capacity: Option<usize>) -> String

Create a new Extend of the correct type
§

fn accumulate(&mut self, acc: &'i str)

Accumulate the input into an accumulator
§

impl Accumulate<char> for String

§

fn initial(capacity: Option<usize>) -> String

Create a new Extend of the correct type
§

fn accumulate(&mut self, acc: char)

Accumulate the input into an accumulator
1.0.0 · source§

impl Add<&str> for String

Implements the + operator for concatenating two strings.

This consumes the String on the left-hand side and re-uses its buffer (growing it if necessary). This is done to avoid allocating a new String and copying the entire contents on every operation, which would lead to O(n^2) running time when building an n-byte string by repeated concatenation.

The string on the right-hand side is only borrowed; its contents are copied into the returned String.

§Examples

Concatenating two Strings takes the first by value and borrows the second:

let a = String::from("hello");
let b = String::from(" world");
let c = a + &b;
// `a` is moved and can no longer be used here.

If you want to keep using the first String, you can clone it and append to the clone instead:

let a = String::from("hello");
let b = String::from(" world");
let c = a.clone() + &b;
// `a` is still valid here.

Concatenating &str slices can be done by converting the first to a String:

let a = "hello";
let b = " world";
let c = a.to_string() + b;
§

type Output = String

The resulting type after applying the + operator.
source§

fn add(self, other: &str) -> String

Performs the + operation. Read more
1.12.0 · source§

impl AddAssign<&str> for String

Implements the += operator for appending to a String.

This has the same behavior as the push_str method.

source§

fn add_assign(&mut self, other: &str)

Performs the += operation. Read more
§

impl<'a> Arbitrary<'a> for String

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<String, Error>

Generate an arbitrary value of Self from the given unstructured data. Read more
§

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<String, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data. Read more
§

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more
§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more
§

impl Archive for String

§

type Archived = ArchivedString

The archived representation of this type. Read more
§

type Resolver = StringResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.
§

fn resolve( &self, resolver: <String as Archive>::Resolver, out: Place<<String as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output. Read more
§

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize. Read more
§

impl Arg for String

§

fn as_str(&self) -> Result<&str, Errno>

Returns a view of this string as a string slice.
§

fn to_string_lossy(&self) -> Cow<'_, str>

Returns a potentially-lossy rendering of this string as a Cow<'_, str>.
§

fn as_cow_c_str(&self) -> Result<Cow<'_, CStr>, Errno>

Returns a view of this string as a maybe-owned CStr.
§

fn into_c_str<'b>(self) -> Result<Cow<'b, CStr>, Errno>
where String: 'b,

Consumes self and returns a view of this string as a maybe-owned CStr.
§

fn into_with_c_str<T, F>(self, f: F) -> Result<T, Errno>
where String: Sized, F: FnOnce(&CStr) -> Result<T, Errno>,

Runs a closure with self passed in as a &CStr.
1.43.0 · source§

impl AsMut<str> for String

source§

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.
1.0.0 · source§

impl AsRef<[u8]> for String

source§

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

Converts this type into a shared reference of the (usually inferred) input type.
1.0.0 · source§

impl AsRef<OsStr> for String

source§

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.
1.0.0 · source§

impl AsRef<Path> for String

source§

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.
§

impl AsRef<Utf8Path> for String

§

fn as_ref(&self) -> &Utf8Path

Converts this type into a shared reference of the (usually inferred) input type.
1.0.0 · source§

impl AsRef<str> for String

source§

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.
§

impl Body for String

§

type Data = Bytes

Values yielded by the Body.
§

type Error = Infallible

The error type this Body might generate.
§

fn poll_frame( self: Pin<&mut String>, _cx: &mut Context<'_>, ) -> Poll<Option<Result<Frame<<String as Body>::Data>, <String as Body>::Error>>>

Attempt to pull out the next data buffer of this stream.
§

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached. Read more
§

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream. Read more
§

impl Borrow<BStr> for String

§

fn borrow(&self) -> &BStr

Immutably borrows from an owned value. Read more
1.0.0 · source§

impl Borrow<str> for String

source§

fn borrow(&self) -> &str

Immutably borrows from an owned value. Read more
1.36.0 · source§

impl BorrowMut<str> for String

source§

fn borrow_mut(&mut self) -> &mut str

Mutably borrows from an owned value. Read more
source§

impl Clear for String

source§

fn clear(&mut self)

Clear all data in self, retaining the allocated capacithy.
1.0.0 · source§

impl Clone for String

source§

fn clone_from(&mut self, source: &String)

Clones the contents of source into self.

This method is preferred over simply assigning source.clone() to self, as it avoids reallocation if possible.

source§

fn clone(&self) -> String

Returns a copy of the value. Read more
1.0.0 · source§

impl Debug for String

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
1.0.0 · source§

impl Default for String

source§

fn default() -> String

Creates an empty String.

1.0.0 · source§

impl Deref for String

§

type Target = str

The resulting type after dereferencing.
source§

fn deref(&self) -> &str

Dereferences the value.
1.3.0 · source§

impl DerefMut for String

source§

fn deref_mut(&mut self) -> &mut str

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for String

source§

fn deserialize<D>( deserializer: D, ) -> Result<String, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
1.0.0 · source§

impl Display for String

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
§

impl EncodeAsVarULE<str> for String

§

fn encode_var_ule_as_slices<R>(&self, cb: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should be the size of [Self::encode_var_ule_len()]
1.2.0 · source§

impl<'a> Extend<&'a char> for String

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = &'a char>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, _: &'a char)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
1.0.0 · source§

impl<'a> Extend<&'a str> for String

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = &'a str>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, s: &'a str)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
1.45.0 · source§

impl<A> Extend<Box<str, A>> for String
where A: Allocator,

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = Box<str, A>>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
1.19.0 · source§

impl<'a> Extend<Cow<'a, str>> for String

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = Cow<'a, str>>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, s: Cow<'a, str>)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
1.4.0 · source§

impl Extend<String> for String

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = String>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, s: String)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
1.0.0 · source§

impl Extend<char> for String

source§

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = char>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, c: char)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

impl FmtConst for String

source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
1.35.0 · source§

impl From<&String> for String

source§

fn from(s: &String) -> String

Converts a &String into a String.

This clones s and returns the clone.

1.44.0 · source§

impl From<&mut str> for String

source§

fn from(s: &mut str) -> String

Converts a &mut str into a String.

The result is allocated on the heap.

1.0.0 · source§

impl From<&str> for String

source§

fn from(s: &str) -> String

Converts a &str into a String.

The result is allocated on the heap.

1.18.0 · source§

impl From<Box<str>> for String

source§

fn from(s: Box<str>) -> String

Converts the given boxed str slice to a String. It is notable that the str slice is owned.

§Examples
let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)
1.14.0 · source§

impl<'a> From<Cow<'a, str>> for String

source§

fn from(s: Cow<'a, str>) -> String

Converts a clone-on-write string to an owned instance of String.

This extracts the owned string, clones the string if it is not already owned.

§Example
// If the string is not owned...
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
// It will allocate on the heap and copy the string.
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");
§

impl From<Id> for String

§

fn from(name: Id) -> String

Converts to this type from the input type.
§

impl From<Str> for String

§

fn from(name: Str) -> String

Converts to this type from the input type.
source§

impl From<Url> for String

String conversion.

source§

fn from(value: Url) -> String

Converts to this type from the input type.
§

impl From<Utf8PathBuf> for String

§

fn from(path: Utf8PathBuf) -> String

Converts to this type from the input type.
1.46.0 · source§

impl From<char> for String

source§

fn from(c: char) -> String

Allocates an owned String from a single character.

§Example
let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);
1.17.0 · source§

impl<'a> FromIterator<&'a char> for String

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = &'a char>,

Creates a value from an iterator. Read more
1.0.0 · source§

impl<'a> FromIterator<&'a str> for String

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = &'a str>,

Creates a value from an iterator. Read more
1.45.0 · source§

impl<A> FromIterator<Box<str, A>> for String
where A: Allocator,

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = Box<str, A>>,

Creates a value from an iterator. Read more
1.19.0 · source§

impl<'a> FromIterator<Cow<'a, str>> for String

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = Cow<'a, str>>,

Creates a value from an iterator. Read more
1.4.0 · source§

impl FromIterator<String> for String

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = String>,

Creates a value from an iterator. Read more
1.0.0 · source§

impl FromIterator<char> for String

source§

fn from_iter<I>(iter: I) -> String
where I: IntoIterator<Item = char>,

Creates a value from an iterator. Read more
§

impl<'a> FromParallelIterator<&'a char> for String

Collects characters from a parallel iterator into a string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = &'a char>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
§

impl<'a> FromParallelIterator<&'a str> for String

Collects string slices from a parallel iterator into a string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = &'a str>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
§

impl FromParallelIterator<Box<str>> for String

Collects boxed strings from a parallel iterator into one large string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = Box<str>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
§

impl<'a> FromParallelIterator<Cow<'a, str>> for String

Collects string slices from a parallel iterator into a string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = Cow<'a, str>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
§

impl FromParallelIterator<String> for String

Collects strings from a parallel iterator into one large string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = String>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
§

impl FromParallelIterator<char> for String

Collects characters from a parallel iterator into a string.

§

fn from_par_iter<I>(par_iter: I) -> String
where I: IntoParallelIterator<Item = char>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
1.0.0 · source§

impl FromStr for String

§

type Err = Infallible

The associated error which can be returned from parsing.
source§

fn from_str(s: &str) -> Result<String, <String as FromStr>::Err>

Parses a string s to return a value of this type. Read more
1.0.0 · source§

impl Hash for String

source§

fn hash<H>(&self, hasher: &mut H)
where H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
1.0.0 · source§

impl<I> Index<I> for String
where I: SliceIndex<str>,

§

type Output = <I as SliceIndex<str>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<I as SliceIndex<str>>::Output

Performs the indexing (container[index]) operation. Read more
1.0.0 · source§

impl<I> IndexMut<I> for String
where I: SliceIndex<str>,

source§

fn index_mut(&mut self, index: I) -> &mut <I as SliceIndex<str>>::Output

Performs the mutable indexing (container[index]) operation. Read more
§

impl IntoClientRequest for String

§

fn into_client_request(self) -> Result<Request<()>, Error>

Convert into a Request that can be used for a client connection.
§

impl IntoClientRequest for String

§

fn into_client_request(self) -> Result<Request<()>, Error>

Convert into a Request that can be used for a client connection.
source§

impl<'de, E> IntoDeserializer<'de, E> for String
where E: Error,

§

type Deserializer = StringDeserializer<E>

The type of the deserializer being converted into.
source§

fn into_deserializer(self) -> StringDeserializer<E>

Convert this value into a deserializer.
§

impl<I> IntoResettable<String> for I
where I: Into<String>,

§

fn into_resettable(self) -> Resettable<String>

Convert to the intended resettable type
§

impl IntoTargetAddr<'static> for String

§

fn into_target_addr(self) -> Result<TargetAddr<'static>, Error>

Converts the value of self to a TargetAddr.
§

impl IsScalar<String> for String

§

type SchemaType = String

The schema marker type this scalar represents.
§

impl JsonSchema for String

§

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword. Read more
§

fn schema_name() -> String

The name of the generated JSON Schema. Read more
§

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type. Read more
§

fn json_schema(_: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type. Read more
§

impl NamedType for String

§

const NAME: &'static str = "String"

The name of this type
1.0.0 · source§

impl Ord for String

source§

fn cmp(&self, other: &String) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
§

impl<'a> ParallelExtend<&'a char> for String

Extends a string with copied characters from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a char>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl<'a> ParallelExtend<&'a str> for String

Extends a string with string slices from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = &'a str>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl ParallelExtend<Box<str>> for String

Extends a string with boxed strings from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = Box<str>>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl<'a> ParallelExtend<Cow<'a, str>> for String

Extends a string with string slices from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = Cow<'a, str>>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl ParallelExtend<String> for String

Extends a string with strings from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = String>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl ParallelExtend<char> for String

Extends a string with characters from a parallel iterator.

§

fn par_extend<I>(&mut self, par_iter: I)
where I: IntoParallelIterator<Item = char>,

Extends an instance of the collection with the elements drawn from the parallel iterator par_iter. Read more
§

impl Parse<'_> for String

§

fn parse(parser: Parser<'_>) -> Result<String, Error>

Attempts to parse Self from parser, returning an error if it could not be parsed. Read more
§

impl Parse<'_> for String

§

fn parse(parser: Parser<'_>) -> Result<String, Error>

Attempts to parse Self from parser, returning an error if it could not be parsed. Read more
§

impl<'a> PartialEq<&'a BStr> for String

§

fn eq(&self, other: &&'a BStr) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a, 'b> PartialEq<&'a Utf8Path> for String

§

fn eq(&self, other: &&'a Utf8Path) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.0.0 · source§

impl<'a, 'b> PartialEq<&'a str> for String

source§

fn eq(&self, other: &&'a str) -> bool

This method tests for self and other values to be equal, and is used by ==.
source§

fn ne(&self, other: &&'a str) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<ArchivedString> for String

§

fn eq(&self, other: &ArchivedString) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<S1> PartialEq<Ascii<S1>> for String
where S1: AsRef<str>,

§

fn eq(&self, other: &Ascii<S1>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<Authority> for String

§

fn eq(&self, other: &Authority) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a> PartialEq<BStr> for String

§

fn eq(&self, other: &BStr) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a> PartialEq<BString> for String

§

fn eq(&self, other: &BString) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<Bytes> for String

§

fn eq(&self, other: &Bytes) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<BytesMut> for String

§

fn eq(&self, other: &BytesMut) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.0.0 · source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for String

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

This method tests for self and other values to be equal, and is used by ==.
source§

fn ne(&self, other: &Cow<'a, str>) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<HeaderValue> for String

§

fn eq(&self, other: &HeaderValue) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<Id> for String

§

fn eq(&self, other: &Id) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<OsStr> for String

§

fn eq(&self, other: &OsStr) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<PathAndQuery> for String

§

fn eq(&self, other: &PathAndQuery) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl PartialEq<Str> for String

§

fn eq(&self, other: &Str) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<const N: usize> PartialEq<TinyAsciiStr<N>> for String

§

fn eq(&self, other: &TinyAsciiStr<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a, 'b> PartialEq<Utf8Path> for String

§

fn eq(&self, other: &Utf8Path) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a, 'b> PartialEq<Utf8PathBuf> for String

§

fn eq(&self, other: &Utf8PathBuf) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialEq<Value> for String

source§

fn eq(&self, other: &Value) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.0.0 · source§

impl<'a, 'b> PartialEq<str> for String

source§

fn eq(&self, other: &str) -> bool

This method tests for self and other values to be equal, and is used by ==.
source§

fn ne(&self, other: &str) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.0.0 · source§

impl PartialEq for String

source§

fn eq(&self, other: &String) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl<'a> PartialOrd<&'a BStr> for String

§

fn partial_cmp(&self, other: &&'a BStr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<'a, 'b> PartialOrd<&'a Utf8Path> for String

§

fn partial_cmp(&self, other: &&'a Utf8Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<ArchivedString> for String

§

fn partial_cmp(&self, other: &ArchivedString) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<Authority> for String

§

fn partial_cmp(&self, other: &Authority) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<'a> PartialOrd<BStr> for String

§

fn partial_cmp(&self, other: &BStr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<'a> PartialOrd<BString> for String

§

fn partial_cmp(&self, other: &BString) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<Bytes> for String

§

fn partial_cmp(&self, other: &Bytes) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<BytesMut> for String

§

fn partial_cmp(&self, other: &BytesMut) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<HeaderValue> for String

§

fn partial_cmp(&self, other: &HeaderValue) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl PartialOrd<PathAndQuery> for String

§

fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<'a, 'b> PartialOrd<Utf8Path> for String

§

fn partial_cmp(&self, other: &Utf8Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<'a, 'b> PartialOrd<Utf8PathBuf> for String

§

fn partial_cmp(&self, other: &Utf8PathBuf) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
1.0.0 · source§

impl PartialOrd for String

source§

fn partial_cmp(&self, other: &String) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl PhfBorrow<str> for String

source§

fn borrow(&self) -> &str

Convert a reference to self to a reference to the borrowed type.
source§

impl PhfHash for String

source§

fn phf_hash<H>(&self, state: &mut H)
where H: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the state provided.
§

impl QueryFragment for String

§

type SchemaType = String

The type in a schema that this QueryFragment represents
§

type VariablesFields = ()

The variables that are required to execute this QueryFragment
§

fn query( _builder: SelectionBuilder<'_, <String as QueryFragment>::SchemaType, <String as QueryFragment>::VariablesFields>, )

Adds this fragment to the query being built by builder
§

const TYPE: Option<&'static str> = None

The name of the type in the GraphQL schema
§

fn name() -> Option<Cow<'static, str>>

The name of this fragment, useful for operations, maybe fragments if we ever support them…
§

impl Replacer for String

§

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String)

Appends possibly empty data to dst to replace the current match. Read more
§

fn no_expansion(&mut self) -> Option<Cow<'_, str>>

Return a fixed unchanging replacement string. Read more
§

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps this Replacer. Read more
§

impl<S> Serialize<S> for String
where S: Fallible + ?Sized, <S as Fallible>::Error: Source, str: SerializeUnsized<S>,

§

fn serialize( &self, serializer: &mut S, ) -> Result<<String as Archive>::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.
source§

impl Serialize for String

source§

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more
§

impl StrConsumer for String

Pushes the str onto the end of the String

§

fn consume(&mut self, buf: &str)

Consume the base64 encoded data in buf
§

impl Stylize for String

§

type Styled = StyledContent<String>

This type with styles applied.
§

fn stylize(self) -> <String as Stylize>::Styled

Styles this type.
§

fn with(self, color: Color) -> Self::Styled

Sets the foreground color.
§

fn on(self, color: Color) -> Self::Styled

Sets the background color.
§

fn underline(self, color: Color) -> Self::Styled

Sets the underline color.
§

fn attribute(self, attr: Attribute) -> Self::Styled

Styles the content with the attribute.
§

fn reset(self) -> Self::Styled

Applies the Reset attribute to the text.
§

fn bold(self) -> Self::Styled

Applies the Bold attribute to the text.
§

fn underlined(self) -> Self::Styled

Applies the Underlined attribute to the text.
§

fn reverse(self) -> Self::Styled

Applies the Reverse attribute to the text.
§

fn dim(self) -> Self::Styled

Applies the Dim attribute to the text.
§

fn italic(self) -> Self::Styled

Applies the Italic attribute to the text.
§

fn negative(self) -> Self::Styled

Applies the Reverse attribute to the text.
Applies the SlowBlink attribute to the text.
Applies the RapidBlink attribute to the text.
§

fn hidden(self) -> Self::Styled

Applies the Hidden attribute to the text.
§

fn crossed_out(self) -> Self::Styled

Applies the CrossedOut attribute to the text.
§

fn black(self) -> Self::Styled

Sets the foreground color to Black.
§

fn on_black(self) -> Self::Styled

Sets the background color to Black.
§

fn underline_black(self) -> Self::Styled

Sets the underline color to Black.
§

fn dark_grey(self) -> Self::Styled

Sets the foreground color to DarkGrey.
§

fn on_dark_grey(self) -> Self::Styled

Sets the background color to DarkGrey.
§

fn underline_dark_grey(self) -> Self::Styled

Sets the underline color to DarkGrey.
§

fn red(self) -> Self::Styled

Sets the foreground color to Red.
§

fn on_red(self) -> Self::Styled

Sets the background color to Red.
§

fn underline_red(self) -> Self::Styled

Sets the underline color to Red.
§

fn dark_red(self) -> Self::Styled

Sets the foreground color to DarkRed.
§

fn on_dark_red(self) -> Self::Styled

Sets the background color to DarkRed.
§

fn underline_dark_red(self) -> Self::Styled

Sets the underline color to DarkRed.
§

fn green(self) -> Self::Styled

Sets the foreground color to Green.
§

fn on_green(self) -> Self::Styled

Sets the background color to Green.
§

fn underline_green(self) -> Self::Styled

Sets the underline color to Green.
§

fn dark_green(self) -> Self::Styled

Sets the foreground color to DarkGreen.
§

fn on_dark_green(self) -> Self::Styled

Sets the background color to DarkGreen.
§

fn underline_dark_green(self) -> Self::Styled

Sets the underline color to DarkGreen.
§

fn yellow(self) -> Self::Styled

Sets the foreground color to Yellow.
§

fn on_yellow(self) -> Self::Styled

Sets the background color to Yellow.
§

fn underline_yellow(self) -> Self::Styled

Sets the underline color to Yellow.
§

fn dark_yellow(self) -> Self::Styled

Sets the foreground color to DarkYellow.
§

fn on_dark_yellow(self) -> Self::Styled

Sets the background color to DarkYellow.
§

fn underline_dark_yellow(self) -> Self::Styled

Sets the underline color to DarkYellow.
§

fn blue(self) -> Self::Styled

Sets the foreground color to Blue.
§

fn on_blue(self) -> Self::Styled

Sets the background color to Blue.
§

fn underline_blue(self) -> Self::Styled

Sets the underline color to Blue.
§

fn dark_blue(self) -> Self::Styled

Sets the foreground color to DarkBlue.
§

fn on_dark_blue(self) -> Self::Styled

Sets the background color to DarkBlue.
§

fn underline_dark_blue(self) -> Self::Styled

Sets the underline color to DarkBlue.
§

fn magenta(self) -> Self::Styled

Sets the foreground color to Magenta.
§

fn on_magenta(self) -> Self::Styled

Sets the background color to Magenta.
§

fn underline_magenta(self) -> Self::Styled

Sets the underline color to Magenta.
§

fn dark_magenta(self) -> Self::Styled

Sets the foreground color to DarkMagenta.
§

fn on_dark_magenta(self) -> Self::Styled

Sets the background color to DarkMagenta.
§

fn underline_dark_magenta(self) -> Self::Styled

Sets the underline color to DarkMagenta.
§

fn cyan(self) -> Self::Styled

Sets the foreground color to Cyan.
§

fn on_cyan(self) -> Self::Styled

Sets the background color to Cyan.
§

fn underline_cyan(self) -> Self::Styled

Sets the underline color to Cyan.
§

fn dark_cyan(self) -> Self::Styled

Sets the foreground color to DarkCyan.
§

fn on_dark_cyan(self) -> Self::Styled

Sets the background color to DarkCyan.
§

fn underline_dark_cyan(self) -> Self::Styled

Sets the underline color to DarkCyan.
§

fn white(self) -> Self::Styled

Sets the foreground color to White.
§

fn on_white(self) -> Self::Styled

Sets the background color to White.
§

fn underline_white(self) -> Self::Styled

Sets the underline color to White.
§

fn grey(self) -> Self::Styled

Sets the foreground color to Grey.
§

fn on_grey(self) -> Self::Styled

Sets the background color to Grey.
§

fn underline_grey(self) -> Self::Styled

Sets the underline color to Grey.
§

impl Target for String

§

fn as_mut_string(&mut self) -> &mut String

§

fn finish(self) -> String

§

type Finished = String

§

impl ToPathSegments for String

§

fn to_path_segments(&self) -> Result<PathSegments, PathSegmentError>

Convert to [PathSegments].
1.16.0 · source§

impl ToSocketAddrs for String

§

type Iter = IntoIter<SocketAddr>

Returned iterator over socket addresses which this type may correspond to.
source§

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>, Error>

Converts this object to an iterator of resolved SocketAddrs. Read more
§

impl<'a> TryFrom<&'a BStr> for String

§

type Error = Utf8Error

The type returned in the event of a conversion error.
§

fn try_from(s: &'a BStr) -> Result<String, Utf8Error>

Performs the conversion.
§

impl TryFrom<BString> for String

§

type Error = FromUtf8Error

The type returned in the event of a conversion error.
§

fn try_from(s: BString) -> Result<String, FromUtf8Error>

Performs the conversion.
§

impl TryFrom<Message> for String

§

type Error = Error

The type returned in the event of a conversion error.
§

fn try_from( value: Message, ) -> Result<String, <String as TryFrom<Message>>::Error>

Performs the conversion.
§

impl TryFrom<Message> for String

§

type Error = Error

The type returned in the event of a conversion error.
§

fn try_from( value: Message, ) -> Result<String, <String as TryFrom<Message>>::Error>

Performs the conversion.
§

impl Value for String

§

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Visits this value with the given Visitor.
§

impl ValueParserFactory for String

§

type Parser = ValueParser

Generated parser, usually [ValueParser]. Read more
§

fn value_parser() -> <String as ValueParserFactory>::Parser

Create the specified [Self::Parser]
1.0.0 · source§

impl Write for String

source§

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded. Read more
source§

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded. Read more
1.0.0 · source§

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait. Read more
§

impl Writeable for String

§

fn write_to<W>(&self, sink: &mut W) -> Result<(), Error>
where W: Write + ?Sized,

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.
§

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink. Read more
§

fn write_to_string(&self) -> Cow<'_, str>

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster. Read more
§

fn writeable_cmp_bytes(&self, other: &[u8]) -> Ordering

Compares the contents of this Writeable to the given bytes without allocating a String to hold the Writeable contents. Read more
§

fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>
where S: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.
§

impl Zeroize for String

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.
§

impl AsHeaderName for String

§

impl CoercesTo<Option<Option<String>>> for String

§

impl CoercesTo<Option<String>> for String

§

impl CoercesTo<Option<Vec<Option<String>>>> for String

§

impl CoercesTo<Option<Vec<String>>> for String

§

impl CoercesTo<String> for String

§

impl CoercesTo<Vec<String>> for String

§

impl CoercesTo<Vec<Vec<String>>> for String

source§

impl DerefPure for String

1.0.0 · source§

impl Eq for String

§

impl<T> FromStream<T> for String
where T: AsRef<str>,

source§

impl Index for String

source§

impl Index for String

Implements the Index trait for String, allowing owned strings to be used as keys for indexing into a Mapping.

source§

impl Index for String

§

impl Index for String

§

impl IntoUrl for String

§

impl StableDeref for String

1.0.0 · source§

impl StructuralPartialEq for String

§

impl ToSocketAddrs for String