Struct gvariant::Str

#[repr(transparent)]pub struct Str { /* fields omitted */ }

Type with same representation as GVariant "s", "o" and "g" types

This is the type returned by:

gv!("s").cast(data);

We can't use Rust's str type here because GVariant strings always end with a NUL byte.

Implementations

impl Str

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

Convert &Str to &[u8]

This will give the same result as s.to_str().as_bytes() for normal data, but unlike using to_str() it should be 0-cost as it doesn't require scanning the underlying data.

The result of this function will deviate from the GLib GVariant implementation if the data contains embedded NULs or non-utf8 data. The spec says:

2.7.3 Handling Non-Normal Serialised Data

String with Embedded Nul

If a string has a nul character as its final byte, but also contains another nul character before this final terminator, the value of the string is taken to be the part of the string that precedes the embedded nul. This means that obtaining a C pointer to a string is still a constant time operation.

Instead this function will return the data with the embedded NULs intact (excluding the final NUL byte)

pub fn to_str(&self) -> &str

Convert &Str to &str

For consistency with the GLib implementation this will return a empty string if the underlying data is not utf-8 encoded or contains embedded NULs. This differs from the wording of the GVariant specification which says that "the use of UTF-8 is expected and encouraged", but it is not guaranteed.

This function executes in linear time with the length of the data. If you know that your data is in normal form you can use self.to_bytes_non_conformant() instead which executes in constant time.

Trait Implementations

impl AlignOf for Str

type AlignOf = A1

impl AllBitPatternsValid for Str

impl Cast for Str

fn default_ref() -> &'static Self

Get a static reference to the default value for this type.

fn try_from_aligned_slice(
    slice: &AlignedSlice<Self::AlignOf>
) -> Result<&Self, WrongSize>

fn try_from_aligned_slice_mut(
    slice: &mut AlignedSlice<Self::AlignOf>
) -> Result<&mut Self, WrongSize>

fn from_aligned_slice(slice: &AlignedSlice<Self::AlignOf>) -> &Self

Cast slice to type Self.

impl Debug for Str

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

Formats the value using the given formatter.

impl Display for Str

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

Formats the value using the given formatter.

impl Eq for Str

impl<'_> From<&'_ Str> for String

fn from(x: &Str) -> Self

Performs the conversion.

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

fn from(x: &'a Str) -> Self

Performs the conversion.

impl PartialEq<Str> for Str

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 PartialEq<Str> for str

fn eq(&self, other: &Str) -> 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 PartialEq<str> for Str

fn eq(&self, other: &str) -> 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 RefCast for Str

type From = [u8]

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl<'_> SerializeTo<Str> for &'_ Str

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<'_> SerializeTo<Str> for &'_ str

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<T: SerializeTo<Str> + Copy, '_> SerializeTo<Str> for &'_ T

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<'_> SerializeTo<Str> for &'_ Box<Str>

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl<'_> SerializeTo<Str> for &'_ String

fn serialize(self, f: &mut impl Write) -> Result<usize>

impl StructuralEq for Str

impl ToOwned for Str

type Owned = Box<Self>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

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

recently added

Uses borrowed data to replace owned data, usually by cloning.