Enum 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

root: Box<DynamicString>

start: usize

length: usize

ConsString

The result of concatenating two DynamicStrings.

Fields

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.

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

Performs the + operation.

impl Clone for DynamicString

fn clone(&self) -> DynamicString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicString

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

Formats the value using the given formatter.

impl Display for DynamicString

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

Formats the value using the given formatter.

impl From<&DynamicString> for IndexedString

fn from(string: &DynamicString) -> Self

Converts to this type from the input type.

impl From<&DynamicString> for String

fn from(str: &DynamicString) -> Self

Converts to this type from the input type.

impl From<DynamicString> for IndexedString

fn from(string: DynamicString) -> Self

Converts to this type from the input type.

impl From<DynamicString> for String

fn from(str: DynamicString) -> Self

Converts to this type from the input type.

impl Hash for DynamicString

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<DynamicString> for &str

fn into(self) -> DynamicString

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

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for DynamicString

fn cmp(&self, other: &Self) -> 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 PartialEq<&str> for DynamicString

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<str> for DynamicString

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 DynamicString

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

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

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 Eq for DynamicString