Struct abi_stable::std_types::string::RString

#[repr(C)]
pub struct RString { /* fields omitted */ }

Ffi-safe equivalent of ::std::string::String

Methods

impl RString

pub fn new() -> Self

Creates a new,empty RString.

pub fn with_capacity(cap: usize) -> Self

Creates a new, empty RString with the capacity to push strings that add up to cap bytes.

pub fn slice<'a, I>(&'a self, i: I) -> RStr<'a> where
    str: Index<I, Output = str>, 

For slicing into RStrs.

This is an inherent method instead of an implementation of the ::std::ops::Index trait because it does not return a reference.

pub fn as_str(&self) -> &str

Creates a &str with access to all the characters of the RString.

pub fn as_rstr(&self) -> RStr

Creates an RStr<'_> with access to all the characters of the RString.

pub const fn len(&self) -> usize

Returns the current length (in bytes) of the RString.

pub const fn capacity(&self) -> usize

Returns the current capacity (in bytes) of the RString.

pub unsafe fn from_utf8_unchecked<V>(vec: RVec<u8>) -> Self where
    V: Into<RVec<u8>>, 

pub fn from_utf8<V>(vec: V) -> Result<Self, FromUtf8Error> where
    V: Into<RVec<u8>>, 

Converts the vec vector of bytes to an RString.

Errors

This will return a Err(FromUtf8Error{..}) if vec was not valid utf-8.

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

Decodes a utf-16 encoded &[u16] to an RString.

Errors

This will return a Err(::std::string::FromUtf16Error{..}) if vec was not valid utf-8.

Important traits for RVec<u8>

impl Write for RVec<u8>

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

Cheap conversion of this RString to a RVec<u8>

pub fn into_string(self) -> String

Converts this RString to a String.

Allocation

If this is invoked outside of the dynamic library/binary that created it, it will allocate a new String and move the data into it.

pub fn to_string(&self) -> String

Copies the RString into a String.

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

Reserves àdditional additional capacity for any extra string data. This may reserve more than necessary for the additional capacity.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the RString to match its

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

Reserves àdditional additional capacity for any extra string data.

Prefer using reserve for most situations.

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

Appends the ch char at the end of this RString.

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

Appends the s &str at the end of this RString.

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

Removes the last character, returns Some(_) if this RString is not empty, otherwise returns None.

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

Removes and returns the character starting at the idx byte position,

Panics

Panics if the index is out of bounds or if it is not on a char boundary.

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

Insert the ch character at the ìnx byte position.

Panics

Panics if the index is out of bounds or if it is not on a char boundary.

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

Insert the s string at the ìnx byte position.

Panics

Panics if the index is out of bounds or if it is not on a char boundary.

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

Retains only the characters that satisfy the pred predicate

This means that a character will be removed if pred(that_character) returns false.

pub fn clear(&mut self)

Turns this into an empty RString,keeping the same allocated buffer.

impl RString

Important traits for Drain<'a>

impl<'a> Iterator for Drain<'a> type Item = char;

pub fn drain<I>(&mut self, range: I) -> Drain where
    str: Index<I, Output = str>, 

Creates an iterator that yields the chars in the range, removing the characters in that range in the process.

Panic

Panics if the start or end of the range are not on a on a char boundary, or if it is out of bounds.

Trait Implementations

impl IntoReprRust for RString

type ReprRust = String

fn into_rust(self) -> Self::ReprRust

impl SharedStableAbi for RString

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

type Kind = __ValueKind

The kind of abi stability of this type,there are 2:

type StaticEquivalent = RString

A version of the type which does not borrow anything, used to create a UTypeId for doing layout checking.

const S_LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

const S_ABI_INFO: &'static AbiInfoWrapper

The layout of the type,derived from Self::LAYOUT and associated types.

impl PartialEq<RString> for RString

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

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

#[must_use]

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

This method tests for !=.

impl AsRef<str> for RString

fn as_ref(&self) -> &str

Performs the conversion.

impl Default for RString

Returns an empty RString

fn default() -> Self

Returns the "default value" for a type.

impl Clone for RString

fn clone(&self) -> RString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Ord for RString

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Restrict a value to a certain interval.

impl<'a> From<RString> for RCow<'a, str>

fn from(this: RString) -> Self

Performs the conversion.

impl<'a> From<&'a RString> for RCow<'a, str>

fn from(this: &'a RString) -> Self

Performs the conversion.

impl<'a> From<&'a str> for RString

fn from(this: &'a str) -> Self

Performs the conversion.

impl From<String> for RString

fn from(this: String) -> RString

Performs the conversion.

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

fn from(this: Cow<'a, str>) -> Self

Performs the conversion.

impl IntoIterator for RString

type Item = char

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

Important traits for IntoIter

impl Iterator for IntoIter type Item = char;

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl Eq for RString

impl<'a> Into<RString> for RStr<'a>

fn into(self) -> RString

Performs the conversion.

impl Into<String> for RString

fn into(self) -> String

Performs the conversion.

impl<'a> Into<Cow<'a, str>> for RString

fn into(self) -> Cow<'a, str>

Performs the conversion.

impl PartialOrd<RString> for RString

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

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

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

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

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

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

impl Deref for RString

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for RString

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

Formats the value using the given formatter.

impl Debug for RString

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

Formats the value using the given formatter.

impl Hash for RString

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl FromIterator<char> for RString

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

Creates a value from an iterator.

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

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

Creates a value from an iterator.

impl FromStr for RString

type Err = <String as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Write for RString

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

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

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

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<'de> Deserialize<'de> for RString

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

Deserialize this value from the given Serde deserializer.

impl Serialize for RString

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

Serialize this value into the given Serde serializer.