Struct abi_stable::std_types::RStr

#[repr(C)]pub struct RStr<'a> { /* fields omitted */ }

Ffi-safe equivalent of &'a str

Example

This defines a function that returns the first word in a string.

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


#[sabi_extern_fn]
fn first_word(phrase:RStr<'_>)->RStr<'_>{
    match phrase.as_str().split_whitespace().next() {
        Some(x)=>x.into(),
        None=>"".into()
    }
}

Implementations

impl<'a> RStr<'a>

pub const EMPTY: Self

An empty RStr.

impl<'a> RStr<'a>

pub const fn empty() -> Self

Constructs an empty RStr<'a>.

Example

use abi_stable::std_types::RStr;

const STR:RStr<'static>=RStr::empty();

assert_eq!(STR,RStr::from(""));

pub const unsafe fn from_raw_parts(ptr_: *const u8, len: usize) -> Self

Constructs an RStr<'a> from a pointer to the first byte, and a length.

Safety

Callers must ensure that:

• ptr_ points to valid memory,

• ptr_ .. ptr+len range is accessible memory,and is valid utf-8.

• The data that ptr_ points to must be valid for the lifetime of this RStr<'a>

Examples

This function unsafely converts a &str to an RStr<'_>, equivalent to doing RStr::from.

use abi_stable::std_types::RStr;

fn convert(slice_:&str)->RStr<'_>{
    unsafe{
        RStr::from_raw_parts( slice_.as_ptr(), slice_.len() )
    }
}

pub const fn from_str(s: &'a str) -> Self

Converts &'a str to a RStr<'a>.

Example

use abi_stable::std_types::RStr;

assert_eq!(RStr::from_str("").as_str(), "");
assert_eq!(RStr::from_str("Hello").as_str(), "Hello");
assert_eq!(RStr::from_str("World").as_str(), "World");

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

For slicing 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;

let str=RStr::from("What is that.");

assert_eq!(str.slice(..),str);
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 const fn as_rslice(&self) -> RSlice<'a, u8>

Accesses the underlying byte slice.

Example

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

let str=RStr::from("What is that.");
let bytes=RSlice::from("What is that.".as_bytes());

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

pub fn as_str(&self) -> &'a str

Casts this RStr<'a> to a &'a str.

Example

use abi_stable::std_types::RStr;

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

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

Gets a raw pointer to the start of the string slice.

pub const fn len(&self) -> usize

Gets the length(in bytes) of this RStr<'a>.

Example

use abi_stable::std_types::RStr;

assert_eq!(RStr::from("").len(),0);
assert_eq!(RStr::from("a").len(),1);
assert_eq!(RStr::from("What").len(),4);

pub const fn is_empty(&self) -> bool

Queries whether this RStr is empty.

Example

use abi_stable::std_types::RStr;

assert_eq!(RStr::from("").is_empty(),true);
assert_eq!(RStr::from("a").is_empty(),false);
assert_eq!(RStr::from("What").is_empty(),false);

Trait Implementations

impl<'_> AsRef<[u8]> for RStr<'_>

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

Performs the conversion.

impl<'_> AsRef<str> for RStr<'_>

pub fn as_ref(&self) -> &str

Performs the conversion.

impl<'a> Borrow<str> for RStr<'a>

pub fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<'a> Clone for RStr<'a>

pub fn clone(&self) -> RStr<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for RStr<'a>

impl<'a> Debug for RStr<'a>

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

Formats the value using the given formatter.

impl<'a> Default for RStr<'a>

pub fn default() -> Self

Returns the "default value" for a type.

impl<'a> Deref for RStr<'a>

type Target = str

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de> Deserialize<'de> for RStr<'de>

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

Deserialize this value from the given Serde deserializer.

impl<'_> Display for RStr<'_>

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

Formats the value using the given formatter.

impl<'a> Eq for RStr<'a>

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

pub fn from(this: &'a str) -> RStr<'a>

Performs the conversion.

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

pub fn from(this: RStr<'a>) -> Self

Performs the conversion.

impl<'a> GetStaticEquivalent_ for RStr<'a>

type StaticEquivalent = _static_RStr<'static>

impl<'a> Hash for RStr<'a>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a> Into<&'a str> for RStr<'a>

pub fn into(self) -> &'a str

Performs the conversion.

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

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

Performs the conversion.

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

pub fn into(self) -> RString

Performs the conversion.

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

pub fn into(self) -> String

Performs the conversion.

impl<'a> IntoReprRust for RStr<'a>

type ReprRust = &'a str

The #[repr(Rust)] equivalent.

pub fn into_rust(self) -> Self::ReprRust

Performs the conversion

impl<'a> Ord for RStr<'a>

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub 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> PartialEq<RStr<'a>> for RStr<'a>

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialOrd<RStr<'a>> for RStr<'a>

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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<'a> Send for RStr<'a>

impl<'a> Serialize for RStr<'a>

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

Serialize this value into the given Serde serializer.

impl<'a> StableAbi for RStr<'a>

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

impl<'a> Sync for RStr<'a>