Enum dynstr::DynamicString

pub enum DynamicString {
    Empty,
    SingleOneByteChar(u8),
    SingleTwoByteChar(u16),
    SeqOneByteString(Arc<Vec<u8>>),
    SeqTwoByteString(Arc<Vec<u16>>),
    SlicedString {
        root: Box<DynamicString>,
        start: usize,
        length: usize,
    },
    ConsString {
        first: Box<DynamicString>,
        second: Box<DynamicString>,
    },
}

An immutable string representation with efficient memory management for heavy string manipulations.

Variants

Empty

Represents an empty string.

SingleOneByteChar(u8)

The string consists of a single one-byte (u8) character.

SingleTwoByteChar(u16)

The string consists of a single two-byte (u16) character.

SeqOneByteString(Arc<Vec<u8>>)

Sequence of one-byte characters (such as an ASCII text), the sequence must be non-empty.

SeqTwoByteString(Arc<Vec<u16>>)

Sequence of two-byte (utf-16) characters, the sequence must be non-empty.

SlicedString

A view over another DynamicString limited to the provided range.

Fields of SlicedString

root: Box<DynamicString>start: usizelength: usize

ConsString

The result of concatenating two DynamicStrings.

Fields of ConsString

first: Box<DynamicString>second: Box<DynamicString>

Implementations

impl DynamicString

pub fn slice(&self, start: usize, length: usize) -> Self

Extracts a section of a string and returns it as a new string, without modifying the original string.

pub fn append<T: Into<DynamicString>>(&self, other: T) -> Self

Concatenate the current string with another string, returns the result.

use dynstr::DynamicString;
let str = DynamicString::new("hello");
assert_eq!(str.append(" world"), DynamicString::new("hello world"));

pub fn index_of<T: Into<DynamicString>>(&self, pattern: T) -> Option<usize>

Return the index of the first occurrence of the specified value in the current string.

use dynstr::DynamicString;
let str = DynamicString::new("Hello world");
assert_eq!(str.index_of("world"), Some(6));
assert_eq!(str.index_of("world!"), None);

pub fn split<T: Into<DynamicString>>(
    &self,
    separator: T,
    limit: Option<usize>
) -> Vec<DynamicString>

Divides a String into an ordered list of substrings, puts these substrings into a vector, and returns the vector. The division is done by searching for a pattern; where the pattern is provided as the first parameter in the method's call.
This method tries to follow the JavaScript's String.split method in edge cases.

use dynstr::DynamicString;
let str = DynamicString::new("Hello world");
assert_eq!(DynamicString::new("Jack,Joe,John").split(",", None), vec!["Jack", "Joe", "John"]);
assert_eq!(DynamicString::new("Jack,Joe,John").split(",", Some(1)), vec!["Jack"]);
// edge cases:
assert!(DynamicString::new("").split("", None).is_empty());
assert_eq!(DynamicString::new("ABC").split("", None), vec!["A", "B", "C"]);
assert_eq!(DynamicString::new("").split("ABC", None), vec![""]);

pub fn starts_with<T: Into<DynamicString>>(&self, other: T) -> bool

Determines whether a string begins with the characters of a specified string, returning true or false as appropriate.

impl DynamicString

pub fn new(data: &str) -> Self

pub fn empty() -> Self

Returns a new empty string.

pub fn len(&self) -> usize

Returns length of the string.

pub fn has_one_byte_char(&self) -> bool

Returns true if this string only contains one-byte characters.

pub fn flatten(self) -> Self

Flatten this DynamicString.

pub fn iter(&self) -> DynamicStringIterator

Returns an iterator over the characters in this string.

Trait Implementations

impl<T: Into<DynamicString>> Add<T> for DynamicString

type Output = DynamicString

The resulting type after applying the + operator.

pub fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl Clone for DynamicString

pub fn clone(&self) -> DynamicString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicString

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

Formats the value using the given formatter.

impl Display for DynamicString

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

Formats the value using the given formatter.

impl Eq for DynamicString

impl<'_> From<&'_ DynamicString> for IndexedString

pub fn from(string: &DynamicString) -> Self

Performs the conversion.

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

pub fn from(str: &DynamicString) -> Self

Performs the conversion.

impl From<DynamicString> for IndexedString

pub fn from(string: DynamicString) -> Self

Performs the conversion.

impl From<DynamicString> for String

pub fn from(str: DynamicString) -> Self

Performs the conversion.

impl Hash for DynamicString

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'_> Into<DynamicString> for &'_ str

pub fn into(self) -> DynamicString

Performs the conversion.

impl IntoIterator for DynamicString

type Item = u16

The type of the elements being iterated over.

type IntoIter = DynamicStringIterator

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for DynamicString

pub fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'_> PartialEq<&'_ str> for DynamicString

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<DynamicString> for DynamicString

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<str> for DynamicString

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<DynamicString> for DynamicString

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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