Struct basic_text::TextString

pub struct TextString(/* private fields */);

A Basic Text encoded, growable string.

This is an owning string similar to String, but ensures the contents are Basic Text rather than just UTF-8. It’s accompanied by a borrowing TextStr, which plays an analogous role to str.

Examples

You can create a TextString from a literal text string with TextString::from:

use basic_text::{text, TextString};

let hello = TextString::from(text!("Hello, world!"));

You can append a &TextStr with the push_text method:

use basic_text::{text, TextString};

let mut hello = TextString::from(text!("Hello, "));

hello.push_text(text!("world!"));

If you have a String containing a Basic Text string, you can create a TextString from it with the from_text method:

use basic_text::{text, TextString};

// a `String`
let sparkle_heart = "💖".to_owned();

// We know this string is valid, so we'll use `unwrap()`.
let sparkle_heart = TextString::from_text(sparkle_heart).unwrap();

assert_eq!(text!("💖"), &sparkle_heart);

If you have a vector of Basic Text bytes, you can create a String from it with the from_text_vec method:

use basic_text::{text, TextString};

// some bytes, in a vector
let sparkle_heart = vec![240, 159, 146, 150];

// We know these bytes are valid, so we'll use `unwrap()`.
let sparkle_heart = TextString::from_text_vec(sparkle_heart).unwrap();

assert_eq!(text!("💖"), &sparkle_heart);

Implementations

impl TextString

pub const fn new() -> Self

Creates a new empty TextString.

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty TextString with a particular capacity.

pub fn from_text_vec(vec: Vec<u8>) -> Result<Self, FromTextError>

Converts a vector of bytes to a TextString.

pub fn from_text(s: String) -> Result<Self, FromTextError>

Converts a String to a TextString.

pub fn from_text_bytes_lossy(v: &[u8]) -> Cow<'_, TextStr>

Converts a slice of bytes to Basic Text, including invalid characters.

pub fn from_text_lossy(v: &str) -> Cow<'_, TextStr>

Converts a string to Basic Text, including invalid characters.

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

Converts a vector of bytes to a TextString without checking that the string contains valid Basic Text.

Safety

This function is unsafe because it does not check that the bytes passed to it are valid Basic Text. If this constraint is violated, undefined behavior results, as the rest of this crate assumes that &TextStrs are valid Basic Text.

pub const unsafe fn from_text_unchecked(s: String) -> Self

Converts a String to a TextString without checking that the string contains valid Basic Text.

Safety

This function is unsafe because it does not check that the bytes passed to it are valid Basic Text. If this constraint is violated, undefined behavior results, as the rest of this crate assumes that &TextStrs are valid Basic Text.

pub fn into_string(self) -> String

Converts a TextString into a String.

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

Converts a String into a byte vector.

pub fn as_str(&self) -> &str

Extracts a UTF-8 string slice containing the entire TextString.

pub fn as_text(&self) -> &TextStr

Extracts a Basic Text string slice containing the entire TextString.

pub fn as_mut_text(&mut self) -> &mut TextStr

Converts a TextString into a mutable Basic Text string slice.

pub fn push_text(&mut self, s: &TextStr)

Appends a given string slice onto the end of this TextString.

But wait, isn’t NFC closed under concatenation? This is true, but Basic Text has additional restrictions, including that strings start with non-combining codepoints, so it is closed under concatenation.

pub fn capacity(&self) -> usize

Returns this TextString’s capacity, in bytes.

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

Ensures that this TextString’s capacity is at least additional bytes larger than its length.

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

Ensures that this TextString’s capacity is additional bytes larger than its length.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of this TextString to match its length.

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

Returns a byte slice of this TextString’s contents.

pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>

Returns a mutable reference to the contents of this TextString.

Safety

This function is unsafe because it does not check that the bytes passed to it are valid Basic Text. If this constraint is violated, it may cause memory unsafety issues with future users of the String, as the rest of this crate assumes that TextStrings are valid Basic Text.

pub unsafe fn as_mut_string(&mut self) -> &mut String

Returns a mutable reference to the contents of this TextString.

Safety

This function is unsafe because it does not check that the bytes passed to it are valid Basic Text. If this constraint is violated, it may cause memory unsafety issues with future users of the String, as the rest of this crate assumes that TextStrings are valid Basic Text.

pub fn len(&self) -> usize

Returns the length of this TextString, in bytes, not chars or graphemes.

pub fn is_empty(&self) -> bool

Returns true if this TextString has a length of zero, and false otherwise.

pub fn clear(&mut self)

Truncates this String, removing all contents.

pub fn into_boxed_str(self) -> Box<str>

Converts this TextString into a Box<str>.

pub fn into_boxed_text(self) -> Box<TextStr>

Converts this TextString into a Box<TextStr>.

Methods from Deref<Target = TextStr>

pub fn len(&self) -> usize

Returns the length of self.

pub fn is_empty(&self) -> bool

Returns true if self has a length of zero bytes.

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

Converts a text string slice to a byte slice.

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]

Converts a mutable text string slice to a mutable byte slice.

Safety

The caller must ensure that the content of the slice is valid Basic Text before the borrow ends and the underlying TextStr is used.

Use of a TextStr whose contents are not valid Basic Text is undefined behavior.

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

Converts a text string slice to a raw pointer.

pub fn as_mut_ptr(&mut self) -> *mut u8

Converts a mutable text string slice to a raw pointer.

pub fn as_str(&self) -> &str

Extracts a UTF-8 string slice containing the entire TextStr.

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

Divide one text string slice into two at an index.

pub fn split_at_mut(&mut self, mid: usize) -> (&mut Self, &mut Self)

Divide one mutable text string slice into two at an index.

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

Returns an iterator over the chars of a text string slice.

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

Returns an iterator over the chars of a text string slice, and their positions.

pub fn bytes(&self) -> Bytes<'_>

An iterator over the bytes of a text string slice.

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

An iterator over the lines of a text string, as text string slices.

TODO: There should be a TextLines which yields &TextStrs.

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

Returns an iterator of u16 over the string encoded as Basic Text.

pub fn contains<'a, P>(&'a self, pat: P) -> bool

where P: Pattern<'a>,

Returns true if the given pattern matches a sub-slice of this text string slice.

Returns false if it does not.

pub fn starts_with<'a, P>(&'a self, pat: P) -> bool

where P: Pattern<'a>,

Returns true if the given pattern matches a prefix of this text string slice.

Returns false if it does not.

pub fn ends_with<'a, P>(&'a self, pat: P) -> bool

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

Returns true if the given pattern matches a suffix of this text string slice.

Returns false if it does not.

pub fn find<'a, P>(&'a self, pat: P) -> Option<usize>

where P: Pattern<'a>,

Returns the byte index of the first character of this text string slice that matches the pattern.

Returns None if the pattern doesn’t match.

pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

Returns the byte index for the first character of the rightmost match of the pattern in this text string slice.

Returns None if the pattern doesn’t match.

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P>

where P: Pattern<'a>,

An iterator over the disjoint matches of a pattern within the given text string slice.

pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

An iterator over the disjoint matches of a pattern within this text string slice, yielded in reverse order.

TODO: There should be a TextRMatches which yields &TextStrs.

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P>

where P: Pattern<'a>,

An iterator over the disjoint matches of a pattern within this text string slice as well as the index that the match starts at.

TODO: There should be a TextMatchIndices which yields &TextStrs.

pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P>

where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

An iterator over the disjoint matches of a pattern within self, yielded in reverse order along with the index of the match.

TODO: There should be a TextRMatchIndices which yields &TextStrs.

pub fn trim(&self) -> &Self

Returns a text string slice with leading and trailing whitespace removed.

pub fn trim_start(&self) -> &Self

Returns a text string slice with leading whitespace removed.

pub fn trim_end(&self) -> &Self

Returns a text string slice with trailing whitespace removed.

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

where F: FromStr,

Parses this text string slice into another type.

pub fn is_ascii(&self) -> bool

Checks if all characters in this text string are within the ASCII range.

pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool

Checks that two text strings are an ASCII case-insensitive match.

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

Creates a new TextString by repeating a string n times.

pub fn escape_debug(&self) -> EscapeDebug<'_>

Return an iterator that escapes each char in self with char::escape_debug.

pub fn escape_default(&self) -> EscapeDefault<'_>

Return an iterator that escapes each char in self with char::escape_default.

pub fn escape_unicode(&self) -> EscapeUnicode<'_>

Return an iterator that escapes each char in self with char::escape_unicode.

Trait Implementations

impl Add<&TextStr> for TextString

type Output = TextString

The resulting type after applying the + operator.

fn add(self, other: &TextStr) -> Self::Output

Performs the + operation.

impl AddAssign<&TextStr> for TextString

fn add_assign(&mut self, other: &TextStr)

Performs the += operation.

impl AsMut<TextStr> for TextString

fn as_mut(&mut self) -> &mut TextStr

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

impl AsRef<[u8]> for TextString

fn as_ref(&self) -> &[u8]

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

impl AsRef<OsStr> for TextString

fn as_ref(&self) -> &OsStr

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

impl AsRef<Path> for TextString

fn as_ref(&self) -> &Path

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

impl AsRef<TextStr> for TextString

fn as_ref(&self) -> &TextStr

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

impl AsRef<TextSubstr> for TextString

fn as_ref(&self) -> &TextSubstr

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

impl AsRef<str> for TextString

fn as_ref(&self) -> &str

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

impl Borrow<TextStr> for TextString

fn borrow(&self) -> &TextStr

Immutably borrows from an owned value.

impl BorrowMut<TextStr> for TextString

fn borrow_mut(&mut self) -> &mut TextStr

Mutably borrows from an owned value.

impl Clone for TextString

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TextString

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

Formats the value using the given formatter.

impl Default for TextString

fn default() -> TextString

Returns the “default value” for a type.

impl Deref for TextString

type Target = TextStr

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for TextString

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> Extend<&'a TextStr> for TextString

fn extend<I: IntoIterator<Item = &'a TextStr>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, s: &'a TextStr)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<'a> Extend<Cow<'a, TextStr>> for TextString

fn extend<I: IntoIterator<Item = Cow<'a, TextStr>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, s: Cow<'a, TextStr>)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl Extend<TextString> for TextString

fn extend<I: IntoIterator<Item = TextString>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, s: TextString)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl From<&TextStr> for TextString

fn from(s: &TextStr) -> Self

Converts to this type from the input type.

impl From<&TextString> for TextString

fn from(s: &Self) -> Self

Converts to this type from the input type.

impl From<&mut TextStr> for TextString

fn from(s: &mut TextStr) -> Self

Converts to this type from the input type.

impl From<Box<TextStr>> for TextString

fn from(s: Box<TextStr>) -> Self

Converts to this type from the input type.

impl From<TextString> for Box<TextStr>

fn from(s: TextString) -> Self

Converts to this type from the input type.

impl Hash for TextString

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 Index<Range<usize>> for TextString

type Output = TextSubstr

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for TextString

type Output = TextSubstr

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for TextString

type Output = TextSubstr

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> PartialEq<&'a TextStr> for TextString

fn eq(&self, other: &&'a TextStr) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<&'a TextSubstr> for TextString

fn eq(&self, other: &&'a TextSubstr) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<&'a str> for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<Cow<'a, TextStr>> for TextString

fn eq(&self, other: &Cow<'a, TextStr>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<Cow<'a, TextSubstr>> for TextString

fn eq(&self, other: &Cow<'a, TextSubstr>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<Cow<'a, str>> for TextString

fn eq(&self, other: &Cow<'a, str>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<String> for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextStr> for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for &'a TextStr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for &'a TextSubstr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for &'a str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for Cow<'a, TextStr>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for Cow<'a, TextSubstr>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> PartialEq<TextString> for Cow<'a, str>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextString> for String

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextString> for TextStr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextString> for TextSubstr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextString> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<TextSubstr> for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<str> for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for TextString

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for TextString

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for TextString

impl StructuralPartialEq for TextString