Struct abi_stable::std_types::string::RString

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

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

Example

This defines a function returning the last word of an RString.

use abi_stable::{
    std_types::RString,
    sabi_extern_fn,
};


#[sabi_extern_fn]
fn first_word(phrase:RString)->RString{
    match phrase.split_whitespace().next_back() {
        Some(x)=>x.into(),
        None=>RString::new(),
    }
}

Methods

impl RString

pub const fn new() -> Self

Creates a new,empty RString.

Example

use abi_stable::std_types::RString;

let str=RString::new();
 
assert_eq!(&str[..],"");

pub fn with_capacity(cap: usize) -> Self

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

Example

use abi_stable::std_types::RString;

let str=RString::with_capacity(10);
 
assert_eq!(&str[..],"");
assert_eq!(str.capacity(),10);

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.

Example

use abi_stable::std_types::{RStr,RString};

let str=RString::from("What is that.");
 
assert_eq!(str.slice(..),RStr::from("What is that."));
assert_eq!(str.slice(..4),RStr::from("What"));
assert_eq!(str.slice(4..),RStr::from(" is that."));
assert_eq!(str.slice(4..7),RStr::from(" is"));

pub fn as_str(&self) -> &str

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

Example

use abi_stable::std_types::RString;

let str="What is that.";
assert_eq!(RString::from(str).as_str(),str);

pub const fn as_rstr(&self) -> RStr

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

Example

use abi_stable::std_types::{RStr,RString};

let str="What is that.";
assert_eq!(
    RString::from(str).as_rstr(),
    RStr::from(str),
);

pub const fn len(&self) -> usize

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

Example

use abi_stable::std_types::RString;

assert_eq!(RString::from("").len(),0);
assert_eq!(RString::from("a").len(),1);
assert_eq!(RString::from("Regular").len(),7);

pub const fn as_ptr(&self) -> *const u8

Gets a raw pointer to the start of this RString's buffer.

pub const fn capacity(&self) -> usize

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

Example

use abi_stable::std_types::RString;

let mut str=RString::with_capacity(13);

assert_eq!(str.capacity(),13);

str.push_str("What is that.");
assert_eq!(str.capacity(),13);

str.push(' ');
assert_ne!(str.capacity(),13);

pub const unsafe fn from_utf8_unchecked(vec: RVec<u8>) -> Self

An unchecked conversion from a RVec<u8> to an RString.

Examples

use abi_stable::std_types::{RString,RVec};

let bytes=RVec::from("hello".as_bytes());

unsafe{
    assert_eq!( RString::from_utf8_unchecked(bytes).as_str(), "hello" );
}

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.

Examples

use abi_stable::std_types::{RString,RVec};

let bytes_ok=RVec::from("hello".as_bytes());
let bytes_err=RVec::from(vec![255]);

assert_eq!( RString::from_utf8(bytes_ok).unwrap(), RString::from("hello") );
assert!( RString::from_utf8(bytes_err).is_err() );

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.

Example

use abi_stable::std_types::RString;
 
let str="What the 😈.";
let str_utf16=str.encode_utf16().collect::<Vec<u16>>();

assert_eq!(
    RString::from_utf16(&str_utf16).unwrap(),
    RString::from(str),
);

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>

Example

use abi_stable::std_types::{RString,RVec};

let bytes=RVec::from("hello".as_bytes());
let str=RString::from("hello");

assert_eq!(str.into_bytes(),bytes);

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.

Example

use abi_stable::std_types::RString;

let std_str=String::from("hello");
let str=RString::from("hello");

assert_eq!(str.into_string(),std_str);

pub fn to_string(&self) -> String

Copies the RString into a String.

Example

use abi_stable::std_types::RString;

assert_eq!(RString::from("world").to_string(), String::from("world"));

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.

Example

use abi_stable::std_types::RString;

let mut str=RString::new();

str.reserve(10);
assert!(str.capacity()>=10);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the RString to match its length.

Example

use abi_stable::std_types::RString;

let mut str=RString::with_capacity(100);
str.push_str("nope");
str.shrink_to_fit();
assert_eq!(str.capacity(),4);

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

Reserves àdditional additional capacity for any extra string data.

Prefer using reserve for most situations.

Example

use abi_stable::std_types::RString;

let mut str=RString::new();

str.reserve_exact(10);
assert_eq!(str.capacity(),10);

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

Appends the ch char at the end of this RString.

Example

use abi_stable::std_types::RString;

let mut str=RString::new();

str.push('O');
str.push('O');
str.push('P');

assert_eq!(str.as_str(),"OOP");

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

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

Example

use abi_stable::std_types::RString;

let mut str=RString::new();

str.push_str("green ");
str.push_str("frog");

assert_eq!(str.as_str(),"green frog");

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

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

Example

use abi_stable::std_types::{RString,RVec};

let mut str=RString::from("yep");

assert_eq!(str.pop(),Some('p'));
assert_eq!(str.pop(),Some('e'));
assert_eq!(str.pop(),Some('y'));
assert_eq!(str.pop(),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.

Example

use abi_stable::std_types::{RString,RVec};

let mut str=RString::from("Galileo");

assert_eq!(str.remove(3),'i');
assert_eq!(str.as_str(),"Galleo");

assert_eq!(str.remove(4),'e');
assert_eq!(str.as_str(),"Gallo");

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.

Example

use abi_stable::std_types::{RString,RVec};

let mut str=RString::from("Cap");

str.insert(1,'r');
assert_eq!(str.as_str(),"Crap");

str.insert(4,'p');
assert_eq!(str.as_str(),"Crapp");

str.insert(5,'y');
assert_eq!(str.as_str(),"Crappy");

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.

Example

use abi_stable::std_types::{RString,RVec};

let mut str=RString::from("rust");

str.insert_str(0,"T");
assert_eq!(str.as_str(),"Trust");

str.insert_str(5," the source");
assert_eq!(str.as_str(),"Trust the source");

str.insert_str(5," the types in");
assert_eq!(str.as_str(),"Trust the types in the source");

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.

Example

use abi_stable::std_types::{RString,RVec};

{
    let mut str=RString::from("There were 10 people.");
    str.retain(|c| !c.is_numeric() );
    assert_eq!(str.as_str(),"There were  people.");
}
{
    let mut str=RString::from("There were 10 people.");
    str.retain(|c| !c.is_whitespace() );
    assert_eq!(str.as_str(),"Therewere10people.");
}
{
    let mut str=RString::from("There were 10 people.");
    str.retain(|c| c.is_numeric() );
    assert_eq!(str.as_str(),"10");
}

pub fn clear(&mut self)

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

Example

use abi_stable::std_types::{RString,RVec};

let mut str=RString::from("Nurse");

assert_eq!(str.as_str(),"Nurse");
 
str.clear();
 
assert_eq!(str.as_str(),"");

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.

Example

use abi_stable::std_types::RString;

let orig="Not a single way";

{
    let mut str=RString::from(orig);
    assert_eq!(
        str.drain(..).collect::<String>(),
        orig,
    );
    assert_eq!(str.as_str(),"");
}
{
    let mut str=RString::from(orig);
    assert_eq!(
        str.drain(..4).collect::<String>(),
        "Not ",
    );
    assert_eq!(str.as_str(),"a single way");
}
{
    let mut str=RString::from(orig);
    assert_eq!(
        str.drain(4..).collect::<String>(),
        "a single way",
    );
    assert_eq!(str.as_str(),"Not ");
}
{
    let mut str=RString::from(orig);
    assert_eq!(
        str.drain(4..13).collect::<String>(),
        "a single ",
    );
    assert_eq!(str.as_str(),"Not way");
}

Trait Implementations

impl IntoReprRust for RString

type ReprRust = String

fn into_rust(self) -> Self::ReprRust

impl GetStaticEquivalent_ for RString

type StaticEquivalent = _static_RString

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:

const S_LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

const S_ABI_CONSTS: AbiConsts

impl AsRef<str> for RString

fn as_ref(&self) -> &str

Performs the conversion.

impl AsRef<[u8]> for RString

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

Performs the conversion.

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<'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 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 Default for RString

Returns an empty RString

fn default() -> Self

Returns the "default value" for a type.

impl Eq for RString

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 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 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 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 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 Deref for RString

type Target = str

The resulting type after dereferencing.

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

Dereferences the value.

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 Write for RString

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

Writes a string slice 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 Borrow<str> for RString

fn borrow(&self) -> &str

Immutably borrows from an owned value.

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.