Struct heapless::String [−][src]
pub struct String<const N: usize> { /* fields omitted */ }
Expand description
A fixed capacity String
Implementations
Constructs a new, empty String
with a fixed capacity of N
Examples
Basic usage:
use heapless::String; // allocate the string on the stack let mut s: String<4> = String::new(); // allocate the string in a static variable static mut S: String<4> = String::new();
Converts a String
into a byte vector.
This consumes the String
, so we do not need to copy its contents.
Examples
Basic usage:
use heapless::String; let s: String<4> = String::from("ab"); let b = s.into_bytes(); assert!(b.len() == 2); assert_eq!(&['a' as u8, 'b' as u8], &b[..]);
Extracts a string slice containing the entire string.
Examples
Basic usage:
use heapless::String; let mut s: String<4> = String::from("ab"); assert!(s.as_str() == "ab"); let _s = s.as_str(); // s.push('c'); // <- cannot borrow `s` as mutable because it is also borrowed as immutable
Converts a String
into a mutable string slice.
Examples
Basic usage:
use heapless::String; let mut s: String<4> = String::from("ab"); let s = s.as_mut_str(); s.make_ascii_uppercase();
Returns a mutable reference to the contents of this String
.
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 library assumes that String
s are valid UTF-8.
Examples
Basic usage:
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");
Appends a given string slice onto the end of this String
.
Examples
Basic usage:
use heapless::String; let mut s: String<8> = String::from("foo"); assert!(s.push_str("bar").is_ok()); assert_eq!("foobar", s); assert!(s.push_str("tender").is_err());
Returns the maximum number of elements the String can hold
Examples
Basic usage:
use heapless::String; let mut s: String<4> = String::new(); assert!(s.capacity() == 4);
Shortens this String
to the specified length.
If new_len
is greater than 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
Basic usage:
use heapless::String; let mut s: String<8> = String::from("hello"); s.truncate(2); assert_eq!("he", s);
Removes the last character from the string buffer and returns it.
Returns None
if this String
is empty.
Examples
Basic usage:
use heapless::String; let mut s: String<8> = String::from("foo"); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('f')); assert_eq!(s.pop(), None);
Truncates this String
, removing all contents.
While this means the String
will have a length of zero, it does not
touch its capacity.
Examples
Basic usage:
use heapless::String; let mut s: String<8> = String::from("foo"); s.clear(); assert!(s.is_empty()); assert_eq!(0, s.len()); assert_eq!(8, s.capacity());
Trait Implementations
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Writes a string slice into this writer, returning whether the write succeeded. Read more