Type Alias gossip_kv::server::MessageId

pub type MessageId = String;

Aliased Type

struct MessageId { /* private fields */ }

Implementations

impl String

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

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

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.

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.

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

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

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

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

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

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

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

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

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

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

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[..]);

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

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

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

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

pub fn capacity(&self) -> usize

Returns this String’s capacity, in bytes.

Examples

let s = String::with_capacity(10);

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

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

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

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)
}

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)
}

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

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

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

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

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

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

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

pub fn remove_matches<P>(&mut self, pat: P)

where P: Pattern,

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

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

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

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

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

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

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

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

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

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

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

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

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 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.

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

Performs the + operation.

impl AddAssign<&str> for String

Implements the += operator for appending to a String.

This has the same behavior as the push_str method.

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

Performs the += operation.

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.

impl AsMut<str> for String

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

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

impl AsRef<[u8]> for String

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

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

impl AsRef<OsStr> for String

fn as_ref(&self) -> &OsStr

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

impl AsRef<Path> for String

fn as_ref(&self) -> &Path

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

impl AsRef<str> for String

fn as_ref(&self) -> &str

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

impl Borrow<str> for String

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl BorrowMut<str> for String

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

Mutably borrows from an owned value.

impl Clear for String

fn clear(&mut self)

Clear this make, make it equivalent to newly created object.

impl Clear for String

fn clear(&mut self)

Clears the collection without neccesarily freeing allocations.

impl Clone for String

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.

fn clone(&self) -> String

Returns a copy of the value.

impl Debug for String

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

Formats the value using the given formatter.

impl Default for String

fn default() -> String

Creates an empty String.

impl DerefMut for String

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

Mutably dereferences the value.

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

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for String

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

Formats the value using the given formatter.

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

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = &'a char>,

Extends a collection with the contents of an iterator.

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

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

Extends a collection with exactly one element.

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.

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

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = &'a str>,

Extends a collection with the contents of an iterator.

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

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

Extends a collection with exactly one element.

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.

impl<A> Extend<Box<str, A>> for String

where A: Allocator,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Box<str, A>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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.

impl<A> Extend<Box<str, A>> for String

where A: Allocator,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Box<str, A>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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.

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

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Cow<'a, str>>,

Extends a collection with the contents of an iterator.

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.

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.

impl Extend<String> for String

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = String>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, s: String)

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

Extends a collection with exactly one element.

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.

impl Extend<char> for String

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = char>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, c: char)

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

Extends a collection with exactly one element.

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.

impl From<&String> for String

fn from(s: &String) -> String

Converts a &String into a String.

This clones s and returns the clone.

impl From<&mut str> for String

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

Converts a &mut str into a String.

The result is allocated on the heap.

impl From<&str> for String

fn from(s: &str) -> String

Converts a &str into a String.

The result is allocated on the heap.

impl From<Box<str>> for String

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)

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

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.

impl From<Url> for String

String conversion.

fn from(value: Url) -> String

Converts to this type from the input type.

impl From<Uuid> for String

fn from(uuid: Uuid) -> String

Converts to this type from the input type.

impl From<char> for String

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[..]);

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

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = &'a char>,

Creates a value from an iterator.

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

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = &'a str>,

Creates a value from an iterator.

impl<A> FromIterator<Box<str, A>> for String

where A: Allocator,

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = Box<str, A>>,

Creates a value from an iterator.

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

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = Cow<'a, str>>,

Creates a value from an iterator.

impl FromIterator<String> for String

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = String>,

Creates a value from an iterator.

impl FromIterator<char> for String

fn from_iter<I>(iter: I) -> String

where I: IntoIterator<Item = char>,

Creates a value from an iterator.

impl FromStr for String

type Err = Infallible

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for String

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

where H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IdentFragment for String

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

Format this value as an identifier fragment.

fn span(&self) -> Option<Span>

Span associated with this IdentFragment.

impl<I> Index<I> for String

where I: SliceIndex<str>,

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

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for String

where I: SliceIndex<str>,

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

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

impl<'de, E> IntoDeserializer<'de, E> for String

where E: Error,

type Deserializer = StringDeserializer<E>

The type of the deserializer being converted into.

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 Ord for String

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Value> for String

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

Tests for self and other values to be equal, and is used by ==.

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

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

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for String

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

Tests for self and other values to be equal, and is used by ==.

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

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

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.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for String

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ProtobufValue for String

fn as_ref(&self) -> ReflectValueRef<'_>

As ref

fn as_any(&self) -> &(dyn Any + 'static)

Convert to Any

fn is_non_zero(&self) -> bool

Is value non-zero?

fn as_ref_copy(&self) -> ReflectValueRef<'static>

Return ProtobufValueRef if self is Copy.

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.

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

Return a fixed unchanging replacement string.

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

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

impl Serialize for String

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.

impl Target for String

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

fn finish(self) -> String

type Finished = String

impl ToSocketAddrs for String

type Iter = IntoIter<SocketAddr>

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

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

Converts this object to an iterator of resolved SocketAddrs.

impl ToTokens for String

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

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].

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

Create the specified [Self::Parser]

impl Write for String

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

Writes a string slice into this writer, returning whether the write succeeded.

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

Writes a char into this writer, returning whether the write succeeded.

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

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

impl Deref for String

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl DerefPure for String

impl Eq for String

impl<T> FromStream<T> for String

where T: AsRef<str>,

impl Index for String

impl StructuralPartialEq for String

impl ToSocketAddrs for String