Struct LxString

pub struct LxString { /* private fields */ }

An owned string that may or may not be valid utf-8.

This is analogous to OsString on Linux, but behaves the same on all platforms.

Implementations

impl LxString

pub fn new() -> Self

Creates an empty LxString.

pub fn from_vec(vec: Vec<u8>) -> Self

Creates a LxString from a byte vector.

pub fn with_capacity(capacity: usize) -> Self

Creates a LxString with the specified capacity.

pub fn into_vec(self) -> Vec<u8>

Yields the underlying byte vector of this LxString.

pub fn into_string(self) -> Result<String, Self>

Converts the LxString into a String if it contains valid Unicode data.

pub fn as_lx_str(&self) -> &LxStr

Converts to an LxStr slice.

pub fn capacity(&self) -> usize

Returns the capacity of the LxString.

pub fn clear(&mut self)

Clears the contents of the LxString.

pub fn push(&mut self, s: &impl AsRef<LxStr>)

Extends the string with the given &OsStr slice.

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

Reserves capacity for at least additional more capacity to be inserted in the given OsString.

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

Reserves the minimum capacity for exactly additional more capacity to be inserted in the given LxString. Does nothing if the capacity is already sufficient.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the LxString to match its length.

Methods from Deref<Target = LxStr>

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

Gets the underlying byte view of the LxStr slice.

pub fn to_lx_string(&self) -> LxString

Copies the slice into an owned LxString.

pub fn len(&self) -> usize

Returns the length of this LxStr.

pub fn is_empty(&self) -> bool

Checks whether the LxStr is empty.

pub fn to_str(&self) -> Option<&str>

Yields a &str slice if the LxStr is valid Unicode.

pub fn to_string_lossy(&self) -> Cow<'_, str>

Convert an LxStr to a Cow<str>.

Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.

Trait Implementations

impl AsRef<LxStr> for LxString

fn as_ref(&self) -> &LxStr

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<LxStr> for LxString

fn borrow(&self) -> &LxStr

Immutably borrows from an owned value.

impl Clone for LxString

fn clone(&self) -> LxString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LxString

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

Formats the value using the given formatter.

impl Default for LxString

fn default() -> LxString

Returns the “default value” for a type.

impl Deref for LxString

type Target = LxStr

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> From<&T> for LxString

where T: ?Sized + AsRef<LxStr>,

fn from(s: &T) -> Self

Converts to this type from the input type.

impl From<String> for LxString

fn from(s: String) -> Self

Converts to this type from the input type.

impl Hash for LxString

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<&str> for LxString

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<LxString> for &str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<LxString> for str

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for LxString

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for LxString

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for LxString

impl StructuralPartialEq for LxString