Struct SmtString 

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

An SMT-LIB string is a sequence of characters with unicode code points in the range 0x0000 to 0x2FFFF (first two planes of Unicode). The characters are represented by the SmtChar type.

Examples

use smt_str::{SmtString, SmtChar};

// Create a new SmtString from a string literal
let s: SmtString = "foo".into();

// Obtain the length of the string
assert_eq!(s.len(), 3);

// SmtStrings have the correct length even for multi-byte characters
let s: SmtString = "🦀".into();
assert_eq!(s.len(), 1);

// In Rust, the length of a string is counted in bytes, not characters
assert_eq!("🦀".len(), 4);
assert_eq!("🦀".chars().count(), 1);

// SmtString can be parsed from a string with escape sequences
let s: SmtString = SmtString::parse(r#"foo\u{61}bar"#);
assert_eq!(s, SmtString::from("fooabar"));

// Printing the string escapes non-printable characters
let s: SmtString = SmtString::from("foo\nbar");
assert_eq!(s.to_string(), r#"foo\u{A}bar"#);

Implementations

impl SmtString

pub fn empty() -> Self

The empty string.

pub fn new(chars: Vec<SmtChar>) -> Self

Create a new SmtString from a vector of SmtChar.

pub fn parse(input: &str) -> Self

Parse a string into an SmtString.

The input string can contain escaped characters. The only valid escape sequences are:

• \uDDDD
• \u{D},
• \u{DD},
• \u{DDD},
• \u{DDDD},
• \u{DDDDD}

where D is a hexadecimal digit such that the resulting code point is in the range 0x0000 to 0x2FFFF. If the string contains valid escape sequences, they are replaced with the corresponding SmtChar. If the string contains invalid escape sequences, they are treated as literals. For example, the string "foo\u{61}bar" is parsed as the string "fooabar". But the string "foo\u{61bar" is parsed as the string "foo\u{61bar". The holds for syntactically valid escape sequences that result in code points outside the valid range. For example, the string "foo\u{3000A}bar" is parsed as the string "foo\u{3000A}bar", since the code point 0x3000A is outside the valid range.

Examples

use smt_str::{SmtString};
let s: SmtString = SmtString::parse(r#"foo\u{61}bar"#);
assert_eq!(s, SmtString::from("fooabar"));

// Invalid escape sequence, treated as literal

let s: SmtString = SmtString::parse(r#"foo\u{61bar"#);
assert_eq!(s, SmtString::from(r#"foo\u{61bar"#));

pub fn is_empty(&self) -> bool

Returns whether this string is empty.

Examples

use smt_str::{SmtString};
assert!(SmtString::empty().is_empty());
let s: SmtString = "foo".into();
assert!(!s.is_empty());

pub fn len(&self) -> usize

Returns the length of this string.

Examples

use smt_str::{SmtString};
assert_eq!(SmtString::empty().len(), 0);
let s: SmtString = "foo".into();
assert_eq!(s.len(), 3);

pub fn clear(&mut self)

Empties this string, removing all characters. After calling this method, the string will be empty.

Examples

use smt_str::{SmtString};
let mut s: SmtString = "foo".into();
s.clear();
assert!(s.is_empty());

pub fn append(&mut self, other: &SmtString)

Appends the characters of other to this string. The characters are appended in order.

Examples

use smt_str::{SmtString, SmtChar};
let mut s: SmtString = "foo".into();
let other: SmtString = "bar".into();
s.append(&other);
let mut iter = s.iter();
assert_eq!(iter.next(), Some(&SmtChar::from('f')));
assert_eq!(iter.next(), Some(&SmtChar::from('o')));
assert_eq!(iter.next(), Some(&SmtChar::from('o')));
assert_eq!(iter.next(), Some(&SmtChar::from('b')));
assert_eq!(iter.next(), Some(&SmtChar::from('a')));
assert_eq!(iter.next(), Some(&SmtChar::from('r')));
assert_eq!(iter.next(), None);

pub fn push(&mut self, c: impl Into<SmtChar>)

Pushes a character to the end of this string.

Examples

use smt_str::{SmtString, SmtChar};
let mut s = SmtString::empty();
s.push(SmtChar::from('f'));
s.push(SmtChar::from('o'));
s.push(SmtChar::from('o'));
assert_eq!(s, SmtString::from("foo"));  

pub fn concat(&self, other: &SmtString) -> SmtString

Concatenates this string with other and returns the result. This is a convenience method that does not modify this string. The characters of other are appended to the characters of this string, see [append].

Examples

use smt_str::{SmtString};
let s1 = SmtString::from("foo");
let s2 = SmtString::from("bar");
let s3 = s1.concat(&s2);
assert_eq!(s3, SmtString::from("foobar"));

pub fn contains_char(&self, c: impl Into<SmtChar>) -> bool

Checks if this string contains a character.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foobar".into();
assert!(s.contains_char('f'));
assert!(s.contains_char('o'));
assert!(s.contains_char('b'));
assert!(!s.contains_char('z'));

pub fn contains(&self, factor: &SmtString) -> bool

Return whether this string contains another string as a factor. This is a naive implementation that checks all possible factors of this string, leading to O(n^2) complexity.

Examples

use smt_str::{SmtString};
let s: SmtString = "foobar".into();
assert!(s.contains(&SmtString::empty()));
assert!(s.contains(&SmtString::from("foo")));
assert!(s.contains(&SmtString::from("bar")));
assert!(s.contains(&SmtString::from("oba")));
assert!(!s.contains(&SmtString::from("baz")));

// The empty string contains only has the empty string as a factor
let empty: SmtString = SmtString::empty();
assert!(empty.contains(&SmtString::empty()));
assert!(!empty.contains(&SmtString::from("foo")));

pub fn index_of(&self, factor: &SmtString, start: usize) -> Option<usize>

Find the index of the first occurrence of a factor in the suffix of this string starting at start. Returns None if the factor is not found. The empty string is a factor of every string and will always return Some(0).

Examples

use smt_str::{SmtString};
let s: SmtString = "foobar".into();
assert_eq!(s.index_of(&SmtString::empty(),0), Some(0));
assert_eq!(s.index_of(&SmtString::from("foo"),0), Some(0));
assert_eq!(s.index_of(&SmtString::from("foo"),1), None);
assert_eq!(s.index_of(&SmtString::from("bar"),0), Some(3));
assert_eq!(s.index_of(&SmtString::from("oba"),0), Some(2));
assert_eq!(s.index_of(&SmtString::from("baz"),0), None);

// If the string is empty, the only factor is the empty string
let empty: SmtString = SmtString::empty();
assert_eq!(empty.index_of(&SmtString::empty(),0), Some(0));
assert_eq!(empty.index_of(&SmtString::from("foo"),0), None);

pub fn starts_with(&self, prefix: &SmtString) -> bool

Returns whether this string starts with a prefix. The empty string is a prefix of every string.

Examples

use smt_str::{SmtString};
let s: SmtString = "foobar".into();
assert!(s.starts_with(&SmtString::empty()));
assert!(s.starts_with(&SmtString::from("foo")));
assert!(!s.starts_with(&SmtString::from("bar")));

pub fn ends_with(&self, suffix: &SmtString) -> bool

Returns whether this string ends with a suffix. The empty string is a suffix of every string.

Examples

use smt_str::{SmtString};
let s: SmtString = "foobar".into();
assert!(s.ends_with(&SmtString::empty()));
assert!(s.ends_with(&SmtString::from("bar")));
assert!(!s.ends_with(&SmtString::from("foo")));

pub fn first(&self) -> Option<SmtChar>

Returns the first character of this string, if it is not empty. Returns None if this string is empty.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foo".into();
assert_eq!(s.first(), Some('f'.into()));
assert_eq!(SmtString::empty().first(), None);

pub fn last(&self) -> Option<SmtChar>

Returns the last character of this string, if it is not empty. Returns None if this string is empty.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foo".into();
assert_eq!(s.last(), Some('o'.into()));
assert_eq!(SmtString::empty().last(), None);

pub fn take(&self, n: usize) -> SmtString

Returns the prefix of length n of this string. If n is greater than the length of this string, the entire string is returned. If n is zero, the empty string is returned.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foo".into();

assert_eq!( s.take(2), SmtString::from("fo"));
assert!(s.take(10) == s);
assert!(s.take(0) == SmtString::empty());

pub fn drop(&self, n: usize) -> SmtString

Returns the suffix of this string after removing the first n characters. If n is greater than the length of this string, the empty string is returned. If n is zero, the entire string is returned.

Examples

use smt_str::{SmtString, SmtChar};
let s = SmtString::from("foo");
assert_eq!(s.drop(2), SmtString::from("o"));
assert_eq!(s.drop(10), SmtString::empty());
assert_eq!(s.drop(0), s);

pub fn nth(&self, n: usize) -> Option<SmtChar>

Returns the n-th character of this string. Returns None if n is greater than or equal to the length of this string.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foo".into();
assert_eq!(s.nth(0), Some(SmtChar::from('f')));
assert_eq!(s.nth(1), Some(SmtChar::from('o')));
assert_eq!(s.nth(2), Some(SmtChar::from('o')));
assert_eq!(s.nth(3), None);

pub fn reversed(&self) -> Self

Returns the reverse of this string.

Examples

use smt_str::{SmtString, SmtChar};
let s: SmtString = "foo".into();
let rev = s.reversed();
let mut iter = rev.iter();
assert_eq!(iter.next(), Some(&SmtChar::from('o')));
assert_eq!(iter.next(), Some(&SmtChar::from('o')));
assert_eq!(iter.next(), Some(&SmtChar::from('f')));
assert_eq!(iter.next(), None);

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

Repeat this string n times. If n is zero, the empty string is returned. If this string is empty, the empty string is returned. If n is one, this string is returned. Otherwise, the string is repeated n times.

Examples

use smt_str::{SmtString, SmtChar};
let s = SmtString::from("foo");
assert_eq!(s.repeat(0), SmtString::empty());
assert_eq!(s.repeat(1), s);
assert_eq!(s.repeat(2), SmtString::from("foofoo"));

pub fn replace(&self, from: &SmtString, to: &SmtString) -> SmtString

Replaces the first occurrence of from in this string with to. If from is not found in this string, the string is returned unchanged.

Examples

use smt_str::{SmtString};
let s: SmtString = "barbar".into();
let from: SmtString = "bar".into();
let to: SmtString = "foo".into();
assert_eq!(s.replace(&from, &to), SmtString::from("foobar"));

pub fn replace_all(&self, from: &SmtString, to: &SmtString) -> SmtString

Replaces all occurrences of from in this string with to. If from is not found in this string, the string is returned unchanged. If from is the empty string, the string is returned unchanged.

Examples

use smt_str::{SmtString};
let s: SmtString = "barbar".into();
let from: SmtString = "bar".into();
let to: SmtString = "foo".into();
assert_eq!(s.replace_all(&from, &to), SmtString::from("foofoo"));

pub fn iter(&self) -> Iter<'_, SmtChar>

Returns an iterator over the characters of this string.

Trait Implementations

impl Arbitrary for SmtString

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl Clone for SmtString

fn clone(&self) -> SmtString

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SmtString

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

Formats the value using the given formatter.

impl Display for SmtString

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

Formats the value using the given formatter.

impl From<&str> for SmtString

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<SmtChar> for SmtString

fn from(c: SmtChar) -> Self

Converts to this type from the input type.

impl From<String> for SmtString

fn from(s: String) -> Self

Converts to this type from the input type.

impl FromIterator<SmtChar> for SmtString

fn from_iter<I: IntoIterator<Item = SmtChar>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<SmtString> for SmtString

fn from_iter<I: IntoIterator<Item = SmtString>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for SmtString

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<usize> for SmtString

type Output = SmtChar

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl PartialEq for SmtString

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

impl StructuralPartialEq for SmtString