Type Alias RCowStr

Help

pub type RCowStr<'a> = RCow<RStr<'a>, RString>;

Expand description

Ffi-safe equivalent of Cow<'a, str>, either an RStr or RString.

§Example

use abi_stable::std_types::{RCow, RCowStr};

fn foo(x: &str) -> RCowStr<'_> {
    if let Some(x) = x.strip_prefix("tri") {
       RCow::from(x.repeat(3))
    } else {
       RCow::from(x)
    }
}

assert_eq!(foo("foo"), "foo");
assert_eq!(foo("bar"), "bar");
assert_eq!(foo("tribaz"), "bazbazbaz");
assert_eq!(foo("triqux"), "quxquxqux");

Aliased Type§

enum RCowStr<'a> {
    Borrowed(RStr<'a>),
    Owned(RString),
}

Variants§

§

Borrowed(RStr<'a>)

§

Owned(RString)

Implementations§

Source §

impl<'a> RCowStr<'a>

Source

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

For converting a &'a [T] to an RCowSlice<'a, T>, most useful when converting from &'a [T;N] because it coerces the array to a slice.

§Example

use abi_stable::std_types::{RCow, RCowStr};

const C: RCowStr<'_> = RCow::from_str("hello");

assert_eq!(C, "hello");

Source

pub fn as_str(&self) -> &str

Borrows this RCow as a str.

§Conditional `const fn`

This function requires the rust_1_64 feature to be const-callable

§Example

use abi_stable::std_types::RCow;

let cow = RCow::from_str("world");

assert_eq!(cow.as_str(), "world")

Source §

impl RCow<B, B::ROwned>
where B: IntoOwned,

Source

pub fn to_mut(&mut self) -> &mut B::ROwned

Get a mutable reference to the owned form of RCow, converting to the owned form if it is currently the borrowed form.

§Examples

use abi_stable::std_types::{RCow, RCowStr};

let mut cow: RCowStr<'_> = RCow::from("Hello");

assert_eq!(&*cow, "Hello");
assert!(cow.is_borrowed());

cow.to_mut().push_str(", world!");

assert!(cow.is_owned());
assert_eq!(cow, RCow::from("Hello, world!"));

Source

pub fn into_owned(self) -> B::ROwned

Unwraps into the owned owner form of RCow, converting to the owned form if it is currently the borrowed form.

§Examples

use abi_stable::std_types::{RCow, RCowStr};

let mut cow: RCowStr<'_> = RCow::from("Hello");

assert_eq!(&*cow, "Hello");

let mut buff = cow.into_owned();
buff.push_str(", world!");

assert_eq!(&*buff, "Hello, world!");

Source

pub fn borrowed(&self) -> &::Target

Gets the contents of the RCow casted to the borrowed variant.

§Examples

use abi_stable::std_types::{RCow, RCowSlice, RSlice};
{
    let cow: RCowSlice<'_, u8> = RCow::from(&[0, 1, 2, 3][..]);
    assert_eq!(cow.borrowed(), RSlice::from_slice(&[0, 1, 2, 3]));
}
{
    let cow: RCowSlice<'_, u8> = RCow::from(vec![0, 1, 2, 3]);
    assert_eq!(cow.borrowed(), RSlice::from_slice(&[0, 1, 2, 3]));
}

Source §

impl<B, O> RCow<B, O>

Source

pub const fn is_borrowed(&self) -> bool

Whether this is a borrowing RCow.

§Examples

use abi_stable::std_types::{RCow, RCowSlice};

{
    let cow: RCowSlice<'_, u8> = RCow::from(&[0, 1, 2, 3][..]);
    assert!(cow.is_borrowed());
}
{
    let cow: RCowSlice<'_, u8> = RCow::from(vec![0, 1, 2, 3]);
    assert!(!cow.is_borrowed());
}

Source

pub const fn is_owned(&self) -> bool

Whether this is an owning RCow.

§Examples

use abi_stable::std_types::{RCow, RCowSlice};

let cow: RCowSlice<'_, u8> = RCow::from(&[0, 1, 2, 3][..]);
assert!(!cow.is_owned());

let cow: RCowSlice<'_, u8> = RCow::from(vec![0, 1, 2, 3]);
assert!(cow.is_owned());