Enum InnerAscii

pub enum InnerAscii {
    Owned(SoftAsciiString),
    Shared(OwningRef<'static, Arc<String>, SoftAsciiStr>),
}

InnerAscii is string data container which can contain either a owned SoftAsciiString or a SoftAsciiStr reference into a shared string buffer.

Variants

Owned(SoftAsciiString)

Shared(OwningRef<'static, Arc<String>, SoftAsciiStr>)

Implementations

impl InnerAscii

pub fn into_shared(self) -> Self

converts this container into on which uses underlying shared data

if the data is already shared nothing is done. If not the owned data is converted into the underlying string buffer and OwningRef is used to enable the shared reference

Note that the underlying buffer is no an SoftAsciiString but a String (from which we happend to know that it fulfills the “is us-ascii” soft constraint). This allows us to have an InnerAscii share data with a possible non us-ascii string buffer as long as the part accessable through the SoftAsciiStr is ascii. Or at last should be ascii as it’s a soft constraint.

impl InnerAscii

pub fn new<S: Into<SoftAsciiString>>(data: S) -> Self

impl InnerAscii

pub fn as_str(&self) -> &str

Methods from Deref<Target = SoftAsciiStr>

pub fn revalidate_soft_constraint( &self, ) -> Result<&SoftAsciiStr, FromSourceError<&str>>

reruns checks if the “is us-ascii” soft constraint is still valid

pub fn as_str(&self) -> &str

pub fn lines(&self) -> SoftAsciiLines<'_>

pub fn split_whitespace(&self) -> SoftAsciiSplitWhitespace<'_>

pub fn char_indices(&self) -> SoftAsciiCharIndices<'_>

pub fn chars(&self) -> SoftAsciiChars<'_>

pub fn split_at(&self, mid: usize) -> (&SoftAsciiStr, &SoftAsciiStr)

pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &SoftAsciiStr

👎Deprecated since 1.1.0: deprecated in std

pub unsafe fn get_unchecked<I>(&self, index: I) -> &SoftAsciiStr

where I: TempSliceIndexHelper,

Proxy of std::str::get_unchecked.

Currently limited to the various range types:

• Range<usize>
• RangeInclusive<usize>
• RangeFrom<usize>
• RangeTo<usize>
• RangeToInclusive<usize>
• RangeFull

Once all methods on SliceIndex are stable this can be implemented using SliceIndex<SoftAsciiStr> bounds.

pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>

where F: FromStr,

pub fn to_lowercase(&self) -> SoftAsciiString

pub fn to_uppercase(&self) -> SoftAsciiString

pub fn repeat(&self, n: usize) -> SoftAsciiString

pub fn trim_right(&self) -> &SoftAsciiStr

👎Deprecated since 1.1.0: deprecated in std

pub fn trim_left(&self) -> &SoftAsciiStr

👎Deprecated since 1.1.0: deprecated in std

pub fn trim_end(&self) -> &SoftAsciiStr

pub fn trim_start(&self) -> &SoftAsciiStr

pub fn trim(&self) -> &SoftAsciiStr

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_char_boundary(&self, index: usize) -> bool

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

pub fn encode_utf16(&self) -> EncodeUtf16<'_>

pub fn is_ascii(&self) -> bool

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

Trait Implementations

impl AsRef<str> for InnerAscii

fn as_ref(&self) -> &str

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

impl Clone for InnerAscii

fn clone(&self) -> InnerAscii

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InnerAscii

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

Formats the value using the given formatter.

impl Deref for InnerAscii

type Target = SoftAsciiStr

The resulting type after dereferencing.

fn deref(&self) -> &SoftAsciiStr

Dereferences the value.

impl<'de> Deserialize<'de> for InnerAscii

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SoftAsciiString> for InnerAscii

fn from(data: SoftAsciiString) -> Self

Converts to this type from the input type.

impl Hash for InnerAscii

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 Into<SoftAsciiString> for InnerAscii

fn into(self) -> SoftAsciiString

Converts this type into the (usually inferred) input type.

impl PartialEq for InnerAscii

fn eq(&self, other: &InnerAscii) -> 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 Serialize for InnerAscii

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for InnerAscii