Struct Str

pub struct Str<'k> { /* private fields */ }

A string value.

The Str::get method can be used to operate on the value as if it’s a standard str. Equality, ordering, and hashing all defer to the str representation.

The value may internally be any one of:

• &'k str.
• &'static str.
• Box<str>.
• Arc<str>.

Implementations

impl Str<'static>

pub const fn new(k: &'static str) -> Str<'static>

Create a new string from a value borrowed for 'static.

impl<'k> Str<'k>

pub const fn new_ref(k: &'k str) -> Str<'k>

Create a new string from a value borrowed for 'k.

The Str::new method should be preferred where possible.

pub const fn by_ref<'b>(&'b self) -> Str<'b>

Get a new string, borrowing data from this one.

pub const fn get(&self) -> &str

Get a reference to the underlying value.

pub const fn get_static(&self) -> Option<&'static str>

Try get a reference to the underlying static value.

If the string was created from Str::new and contains a 'static value then this method will return Some. Otherwise this method will return None.

impl Str<'static>

pub fn new_owned(key: impl Into<Box<str>>) -> Str<'static>

Create a string from an owned value.

Cloning the string will involve cloning the value.

pub fn new_shared(key: impl Into<Arc<str>>) -> Str<'static>

Create a string from a shared value.

Cloning the string will involve cloning the Arc, which may be cheaper than cloning the value itself.

impl<'k> Str<'k>

pub fn new_cow_ref(key: Cow<'k, str>) -> Str<'k>

Create a string from a potentially owned value.

If the value is Cow::Borrowed then this method will defer to Str::new_ref. If the value is Cow::Owned then this method will defer to Str::new_owned.

pub fn to_cow(&self) -> Cow<'static, str>

Get the underlying value as a potentially owned string.

If the string contains a 'static value then this method will return Cow::Borrowed. Otherwise it will return Cow::Owned.

pub fn to_owned(&self) -> Str<'static>

Get a new string, taking an owned copy of the data in this one.

If the string contains a 'static or Arc value then this method is cheap and doesn’t involve cloning. In other cases the underlying value will be passed through Str::new_owned.

pub fn into_string(self) -> String

Convert this string into an owned String.

If the underlying value is already an owned string then this method will return it without allocating.

pub fn to_shared(&self) -> Str<'static>

Get a new string, taking an owned copy of the data in this one.

If the string contains a 'static or Arc value then this method is cheap and doesn’t involve cloning. In other cases the underlying value will be passed through Str::new_shared.

Trait Implementations

impl<'k> AsRef<str> for Str<'k>

fn as_ref(&self) -> &str

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

impl<'k> Borrow<str> for Str<'k>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<'k> Clone for Str<'k>

fn clone(&self) -> Str<'k>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'k> Debug for Str<'k>

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

Formats the value using the given formatter.

impl<'k> Display for Str<'k>

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

Formats the value using the given formatter.

impl<'k> Drop for Str<'k>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, 'b> From<&'a Str<'b>> for Str<'a>

fn from(value: &'a Str<'b>) -> Str<'a>

Converts to this type from the input type.

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

fn from(value: &'k String) -> Str<'k>

Converts to this type from the input type.

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

fn from(value: &'a str) -> Str<'a>

Converts to this type from the input type.

impl From<Arc<str>> for Str<'static>

fn from(value: Arc<str>) -> Str<'static>

Converts to this type from the input type.

impl From<Box<str>> for Str<'static>

fn from(value: Box<str>) -> Str<'static>

Converts to this type from the input type.

impl From<String> for Str<'static>

fn from(value: String) -> Str<'static>

Converts to this type from the input type.

impl<'k> FromValue<'k> for Str<'k>

fn from_value<'a>(value: Value<'k>) -> Option<Str<'k>>

Perform the conversion.

impl<'a> Hash for Str<'a>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for Str<'a>

fn cmp(&self, other: &Str<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, 'b> PartialEq<&'b str> for Str<'a>

fn eq(&self, other: &&'b 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<'a, 'b> PartialEq<Path<'b>> for Str<'a>

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

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

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

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

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

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<'a, 'b> PartialOrd<Str<'b>> for Str<'a>

fn partial_cmp(&self, other: &Str<'b>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'k> Serialize for Str<'k>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'k> ToStr for Str<'k>

fn to_str(&self) -> Str<'_>

Perform the conversion.

impl<'k> ToValue for Str<'k>

fn to_value(&self) -> Value<'_>

Perform the conversion.

impl<'k> Value for Str<'k>

fn stream<'sval, S>(&'sval self, stream: &mut S) -> Result<(), Error>

where S: Stream<'sval> + ?Sized,

Stream this value through a Stream.

fn tag(&self) -> Option<Tag>

Get the tag of this value, if there is one.

fn to_bool(&self) -> Option<bool>

Try convert this value into a boolean.

fn to_f32(&self) -> Option<f32>

Try convert this value into a 32bit binary floating point number.

fn to_f64(&self) -> Option<f64>

Try convert this value into a 64bit binary floating point number.

fn to_i8(&self) -> Option<i8>

Try convert this value into a signed 8bit integer.

fn to_i16(&self) -> Option<i16>

Try convert this value into a signed 16bit integer.

fn to_i32(&self) -> Option<i32>

Try convert this value into a signed 32bit integer.

fn to_i64(&self) -> Option<i64>

Try convert this value into a signed 64bit integer.

fn to_i128(&self) -> Option<i128>

Try convert this value into a signed 128bit integer.

fn to_u8(&self) -> Option<u8>

Try convert this value into an unsigned 8bit integer.

fn to_u16(&self) -> Option<u16>

Try convert this value into an unsigned 16bit integer.

fn to_u32(&self) -> Option<u32>

Try convert this value into an unsigned 32bit integer.

fn to_u64(&self) -> Option<u64>

Try convert this value into an unsigned 64bit integer.

fn to_u128(&self) -> Option<u128>

Try convert this value into an unsigned 128bit integer.

fn to_text(&self) -> Option<&str>

Try convert this value into a text string.

fn to_binary(&self) -> Option<&[u8]>

Try convert this value into a bitstring.

impl<'k> ValueRef<'k> for Str<'k>

fn stream_ref<S>(&self, stream: &mut S) -> Result<(), Error>

where S: Stream<'k> + ?Sized,

Stream this value through a Stream.

impl<'a> Eq for Str<'a>

impl<'k> Send for Str<'k>

impl<'k> Sync for Str<'k>