Struct zalgo_codec_common::zalgo_string::ZalgoString

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

A String that has been encoded with zalgo_encode. This struct can be decoded in-place and also allows iteration over its characters and bytes, both in decoded and encoded form.

If the serde feature is enabled this struct implements the Serialize and Deserialize traits.

Implementations

impl ZalgoString

pub fn new(s: &str) -> Result<Self, Error>

Encodes the given string slice with zalgo_encode and stores the result in a new allocation.

Errors

Returns an error if the input string contains bytes that don’t correspond to printable ASCII characters or newlines.

Examples

assert_eq!(ZalgoString::new("Zalgo")?, "É̺͇͌͏");

Can only encode printable ASCII and newlines:

assert!(ZalgoString::new("❤️").is_err());
assert!(ZalgoString::new("\r").is_err());

pub fn as_str(&self) -> &str

Returns the encoded contents of self as a string slice.

Example

Basic usage

let zs = ZalgoString::new("Oh boy!")?;
assert_eq!(zs.as_str(), "È̯͈͂͏͙́");

Note that ZalgoString implements PartialEq with common string types, so the comparison in the above example could also be done directly

assert_eq!(zs, "È̯͈͂͏͙́");

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

Returns an iterator over the encoded characters of the ZalgoString.

The first character is an “E”, the others are unicode combining characters.

Example

Iterate through the encoded chars:

let zs = ZalgoString::new("42")?;
let mut chars = zs.chars();
assert_eq!(chars.next(), Some('E'));
assert_eq!(chars.next(), Some('\u{314}'));

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

Returns an iterator over the encoded characters of the ZalgoString and their positions.

Example

Combining characters lie deep in the dark depths of Unicode, and may not match with your intuition of what a character is.

let zs = ZalgoString::new("Zalgo")?;
let mut ci = zs.char_indices();
assert_eq!(ci.next(), Some((0, 'E')));
assert_eq!(ci.next(), Some((1,'\u{33a}')));
// Note the 3 here, the combining characters take up two bytes.
assert_eq!(ci.next(), Some((3, '\u{341}')));
// The final character begins at position 9
assert_eq!(ci.next_back(), Some((9, '\u{34f}')));
// even though the length in bytes is 11
assert_eq!(zs.len(), 11);

pub fn decoded_chars(&self) -> DecodedChars<'_>

Returns an iterator over the decoded characters of the ZalgoString.

These characters are guaranteed to be valid ASCII.

Example

let zs = ZalgoString::new("Zlgoa")?;
let mut decoded_chars = zs.decoded_chars();
assert_eq!(decoded_chars.next(), Some('Z'));
assert_eq!(decoded_chars.next_back(), Some('a'));
assert_eq!(decoded_chars.next(), Some('l'));
assert_eq!(decoded_chars.next(), Some('g'));
assert_eq!(decoded_chars.next_back(), Some('o'));
assert_eq!(decoded_chars.next(), None);
assert_eq!(decoded_chars.next_back(), None);

pub fn into_string(self) -> String

Converts self into a String.

This simply returns the underlying String without any cloning or decoding.

Example

Basic usage

let zs = ZalgoString::new("Zalgo\n He comes!")?;
assert_eq!(zs.into_string(), "É̺͇͌͏̨ͯ̀̀̓ͅ͏͍͓́ͅ");

pub fn into_decoded_string(self) -> String

Decodes self into a String in-place.

This method has no effect on the allocated capacity.

Example

Basic usage

let s = "Zalgo";
let zs = ZalgoString::new(s)?;
assert_eq!(s, zs.into_decoded_string());

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

Returns the encoded contents of self as a byte slice.

The first byte is always 69, after that the bytes no longer correspond to ASCII characters.

Example

Basic usage

let zs = ZalgoString::new("Zalgo")?;
let bytes = zs.as_bytes();
assert_eq!(bytes[0], 69);
assert_eq!(&bytes[1..5], &[204, 186, 205, 129]);

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

Returns an iterator over the encoded bytes of the ZalgoString.

Since a ZalgoString always begins with an “E”, the first byte is always 69. After that the bytes no longer correspond to ASCII values.

Example

Basic usage

let zs = ZalgoString::new("Bytes")?;
let mut bytes = zs.bytes();
assert_eq!(bytes.next(), Some(69));
assert_eq!(bytes.nth(5), Some(148));

pub fn decoded_bytes(&self) -> DecodedBytes<'_>

Returns an iterator over the decoded bytes of the ZalgoString.

These bytes are guaranteed to represent valid ASCII.

Example

let zs = ZalgoString::new("Zalgo")?;
let mut decoded_bytes = zs.decoded_bytes();
assert_eq!(decoded_bytes.next(), Some(90));
assert_eq!(decoded_bytes.next_back(), Some(111));
assert_eq!(decoded_bytes.collect::<Vec<u8>>(), vec![97, 108, 103]);

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

Converts self into a byte vector.

This simply returns the underlying buffer without any cloning or decoding.

Example

Basic usage

let zs = ZalgoString::new("Zalgo")?;
assert_eq!(zs.into_bytes(), vec![69, 204, 186, 205, 129, 205, 140, 205, 135, 205, 143]);

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

Decodes self into a byte vector in-place.

This method has no effect on the allocated capacity.

Example

Basic usage

let zs = ZalgoString::new("Zalgo")?;
assert_eq!(b"Zalgo".to_vec(), zs.into_decoded_bytes());

pub fn len(&self) -> usize

Returns the length of self in bytes.

This length is twice the length of the original String plus one.

Example

Basic usage

let zs = ZalgoString::new("Z")?;
assert_eq!(zs.len(), 3);

pub fn capacity(&self) -> usize

Returns the capacity of the underlying encoded string in bytes.

The ZalgoString is preallocated to the needed capacity of twice the length of the original unencoded String plus one. However, this size is not guaranteed since the allocator can choose to allocate more space.

pub fn decoded_len(&self) -> usize

Returns the length of the ZalgoString in bytes if it were to be decoded.

This is computed without any decoding.

Example

Basic usage

let s = "Zalgo, He comes!";
let zs = ZalgoString::new(s)?;
assert_eq!(s.len(), zs.decoded_len());

pub fn decoded_is_empty(&self) -> bool

Returns whether the string would be empty if decoded.

Example

Basic usage

let zs = ZalgoString::new("")?;
assert!(zs.decoded_is_empty());
let zs = ZalgoString::new("Blargh")?;
assert!(!zs.decoded_is_empty());

pub fn push_zalgo_str(&mut self, zalgo_string: &ZalgoString)

Appends the combining characters of a different ZalgoString to the end of self.

Example

let (s1, s2) = ("Zalgo", ", He comes!");

let mut zs1 = ZalgoString::new(s1)?;
let zs2 = ZalgoString::new(s2)?;

zs1.push_zalgo_str(&zs2);

assert_eq!(zs1.into_decoded_string(), format!("{s1}{s2}"));

pub fn as_combining_chars(&self) -> &str

Returns a string slice of just the combining characters of the ZalgoString without the inital ‘E’.

Note that zalgo_decode assumes that the initial ‘E’ is present, and can not decode the result of this method.

Example

let zs = ZalgoString::new("Hi")?;
assert_eq!(zs.as_combining_chars(), "\u{328}\u{349}");

Trait Implementations

impl Add<&ZalgoString> for ZalgoString

Implements the + operator for concaternating two ZalgoStrings. Memorywise it works the same as the Add implementation for the normal String type: it consumes the lefthand side, extends its buffer, and copies the combining characters of the right hand side into it.

type Output = ZalgoString

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&ZalgoString> for ZalgoString

Implements the += operator for appending to a ZalgoString.

This just calls push_zalgo_str.

fn add_assign(&mut self, rhs: &ZalgoString)

Performs the += operation.

impl Clone for ZalgoString

fn clone(&self) -> ZalgoString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ZalgoString

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ZalgoString

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ZalgoString

Displays the encoded form of the ZalgoString.

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

Formats the value using the given formatter.

impl Hash for ZalgoString

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 Ord for ZalgoString

fn cmp(&self, other: &ZalgoString) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq<&str> for ZalgoString

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<Cow<'_, str>> for ZalgoString

fn eq(&self, other: &Cow<'_, 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 ZalgoString

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

fn eq(&self, other: &ZalgoString) -> 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<ZalgoString> for Cow<'_, str>

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

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

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

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 ZalgoString

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

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

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 ZalgoString

impl StructuralEq for ZalgoString

impl StructuralPartialEq for ZalgoString