Struct xous_ipc::String

pub struct String<const N: usize> { /* private fields */ }

Implementations

impl<const N: usize> String<N>

pub fn new() -> String<N>

pub fn volatile_clear(&mut self)

pub fn from_str<T>(src: T) -> String<N>

where T: AsRef<str>,

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

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn from_message(message: &MemoryMessage) -> Result<String<N>, Utf8Error>

Convert a MemoryMessage into a String

pub fn lend(&self, connection: CID) -> Result<Result, Error>

Perform an immutable lend of this String to the specified server. This function will block until the server returns. Note that this convenience should only be used if the server only ever expects to deal with one type of String, ever. Otherwise, this should be implemented in the API and wrapped in an Enum to help decorate the functional target of the string. An example of a server that uses this convencience function is the logger.

pub fn send(self, connection: CID) -> Result<Result, Error>

Move this string from the client into the server.

pub fn clear(&mut self)

Clear the contents of this String and set the length to 0

pub fn to_str(&self) -> &str

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

awful, O(N) implementation because we have to iterate through the entire string and decode variable-length utf8 characters, until we can’t.

pub fn push(&mut self, ch: char) -> Result<usize, Error>

pub fn append(&mut self, s: &str) -> Result<usize, Error>

pub fn push_byte(&mut self, b: u8) -> Result<(), Error>

Trait Implementations

impl<const N: usize> Archive for String<N>

Turn a String into an archived object

type Archived = ArchivedString

The archived version of this type.

type Resolver = StringResolver

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

fn resolve(&self, pos: usize, resolver: Self::Resolver) -> Self::Archived

Creates the archived version of this value at the given position.

impl<const N: usize> AsRef<str> for String<N>

fn as_ref(&self) -> &str

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

impl<const N: usize> Clone for String<N>

fn clone(&self) -> String<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for String<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for String<N>

fn default() -> Self

Returns the “default value” for a type.

impl<D: Fallible + ?Sized, const N: usize> Deserialize<String<N>, D> for ArchivedString

fn deserialize(&self, _deserializer: &mut D) -> Result<String<N>, D::Error>

Deserializes using the given deserializer

impl<const N: usize> Display for String<N>

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

Formats the value using the given formatter.

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

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

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

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<S: Serializer + ?Sized, const N: usize> Serialize<S> for String<N>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

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

impl<const N: usize> Write for String<N>

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<const N: usize> Copy for String<N>

impl<const N: usize> Eq for String<N>