Struct GString

pub struct GString { /* private fields */ }

String with support for Unicode graphemes

Implementations

impl GString

pub fn from(s: &str) -> GString

Create a new GString from a &str

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);

assert_eq!(s, S);

pub fn graphemes(&self) -> &[String]

Return a slice reference to the internal graphemes

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";
const G: &[&str] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];

let s = GString::from(S);
let g = s.graphemes();

assert_eq!(g, G);
assert_eq!(g.len(), G.len());

pub fn into_graphemes(self) -> Vec<String>

Consume the GString and convert to a Vec of graphemes

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";
const G: &[&str] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];

let g = GString::from(S).into_graphemes();

assert_eq!(g, G);
assert_eq!(g.len(), G.len());

pub fn len(&self) -> usize

Return the count of graphemes

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);
assert_eq!(s.len(), 3);

let s = GString::from("");
assert_eq!(s.len(), 0);

pub fn is_empty(&self) -> bool

Return true if the GString has zero graphemes otherwise return false

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from("");
assert!(s.is_empty());

let s = GString::from(S);
assert!(!s.is_empty());

pub fn chars(&self) -> Vec<char>

Return a Vec of chars

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";
const C: &[char] = &['a', '\u{310}', 'e', '\u{301}', 'o', '\u{308}', '\u{332}'];

let c = GString::from(S).chars();

assert_eq!(c, C);
assert_eq!(c.len(), C.len());

pub fn bytes(&self) -> Vec<u8>

Return a Vec of u8s

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";
const B: &[u8] = &[0x61, 0xcc, 0x90, 0x65, 0xcc, 0x81, 0x6f, 0xcc, 0x88, 0xcc, 0xb2];

let b = GString::from(S).bytes();

assert_eq!(b, B);
assert_eq!(b.len(), B.len());

pub fn insert(&mut self, idx: usize, string: &str)

Insert a string at an index

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let mut s = GString::from("a\u{310}o\u{308}\u{332}");
s.insert(1, "e\u{301}");

assert_eq!(s, S);

pub fn remove(&mut self, idx: usize) -> GString

Remove a grapheme at an index

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let mut s = GString::from(S);

assert_eq!(s.remove(1), "e\u{301}");
assert_eq!(s, "a\u{310}o\u{308}\u{332}");

pub fn push(&mut self, string: &str)

Append a &str

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let mut s = GString::from("a\u{310}e\u{301}");
s.push("o\u{308}\u{332}");

assert_eq!(s, S);

pub fn pop(&mut self) -> Option<GString>

Remove the last grapheme and return it as a new GString

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let mut s = GString::from(S);

assert_eq!(s.pop().unwrap(), "o\u{308}\u{332}");
assert_eq!(s, "a\u{310}e\u{301}");

assert_eq!(s.pop().unwrap(), "e\u{301}");
assert_eq!(s, "a\u{310}");

assert_eq!(s.pop().unwrap(), "a\u{310}");
assert_eq!(s, "");

assert_eq!(s.pop(), None);
assert_eq!(s, "");

pub fn splice<R: RangeBounds<usize>>( &mut self, range: R, replace_with: &str, ) -> GString

Replace a range with a &str

The range can be a a..b Range<usize>, a.. RangeFrom<usize>, ..b RangeTo<usize>, or .. RangeFull.

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let mut s = GString::from(S);

s.splice(0..2, "e\u{301}a\u{310}");
assert_eq!(s, "e\u{301}a\u{310}o\u{308}\u{332}");

s.splice(1.., "o\u{308}\u{332}a\u{310}");
assert_eq!(s, "e\u{301}o\u{308}\u{332}a\u{310}");

s.splice(..1, "");
assert_eq!(s, "o\u{308}\u{332}a\u{310}");

s.splice(.., "");
assert_eq!(s, "");

pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> GString

Remove and return a range of graphemes

The range can be a a..b Range<usize>, a.. RangeFrom<usize>, ..b RangeTo<usize>, or .. RangeFull.

use gstring::*;

let mut s = GString::from("a\u{310}e\u{301}o\u{308}\u{332}a\u{310}e\u{301}");

assert_eq!(s.drain(0..2), "a\u{310}e\u{301}");
assert_eq!(s, "o\u{308}\u{332}a\u{310}e\u{301}");

assert_eq!(s.drain(2..), "e\u{301}");
assert_eq!(s, "o\u{308}\u{332}a\u{310}");

assert_eq!(s.drain(..1), "o\u{308}\u{332}");
assert_eq!(s, "a\u{310}");

assert_eq!(s.drain(..), "a\u{310}");
assert_eq!(s, "");

pub fn slice(&self, range: Range<usize>) -> GString

Create a new GString from an a..b Range<usize>

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);

assert_eq!(s.slice(0..1), "a\u{310}");
assert_eq!(s.slice(1..2), "e\u{301}");
assert_eq!(s.slice(2..3), "o\u{308}\u{332}");
assert_eq!(s.slice(0..2), "a\u{310}e\u{301}");
assert_eq!(s.slice(1..3), "e\u{301}o\u{308}\u{332}");
assert_eq!(s.slice(0..3), S);

See also the GString::index method.

pub fn iter(&self) -> GStringRefIter<'_>

Create a GStringRefIter for iterating graphemes by reference

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);
let mut i = s.iter();

assert_eq!(i.next().unwrap(), "a\u{310}");
assert_eq!(i.next().unwrap(), "e\u{301}");
assert_eq!(i.next().unwrap(), "o\u{308}\u{332}");
assert_eq!(i.next(), None);

See also the GString::into_iter method.

pub fn into_iter(self) -> GStringIter

Consume the GString and convert into a GStringIter for iterating graphemes

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);
let mut i = s.into_iter();

assert_eq!(i.next().unwrap(), "a\u{310}");
assert_eq!(i.next().unwrap(), "e\u{301}");
assert_eq!(i.next().unwrap(), "o\u{308}\u{332}");
assert_eq!(i.next(), None);

See also the GString::iter method.

Trait Implementations

impl Clone for GString

fn clone(&self) -> GString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GString

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

Debug print a GString in format, print, println, write, writeln, etc macros

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

assert_eq!(
    format!("{:?}", GString::from(S)),
    format!("{:?}", S),
);

impl Display for GString

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

Print a GString directly in format, write, etc macros or convert to a String using the to_string method

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);

assert_eq!(format!("{s}"), S);
assert_eq!(format!("{}", s), S);
assert_eq!(s.to_string(), S);

impl<I> Index<I> for GString

where I: SliceIndex<[String]>,

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

Index a slice of GString’s graphemes with a usize index, a..b Range<usize>, a.. RangeFrom<usize>, ..b RangeTo<usize>, or .. RangeFull

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";
const G: &[&str] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];

let s = GString::from(S);

assert_eq!(&s[0], G[0]);
assert_eq!(&s[1], G[1]);
assert_eq!(&s[2], G[2]);

for start in 0..3 {
    for stop in 1..4 {
        if stop > start {
            assert_eq!(&s[start..stop], G[start..stop].to_vec());
            assert_eq!(&s[..stop], G[..stop].to_vec());
        }
    }
    assert_eq!(&s[start..], G[start..].to_vec());
}
assert_eq!(&s[..], G);

See also the GString::slice method.

type Output = <I as SliceIndex<[String]>>::Output

The returned type after indexing.

impl PartialEq<&str> for GString

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

Compare a GString to a &str

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);

assert_eq!(s, S);
assert_ne!(s, "");

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<GString> for &GString

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

Compare a GString to a &GString (or two &GStrings)

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s1 = GString::from(S);
let s2 = GString::from(S);
let empty = GString::from("");

assert_eq!(&s1, s2);
assert_ne!(&s1, empty);

assert_eq!(&s1, &s2);
assert_ne!(&s1, &empty);

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<String> for GString

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

Compare a GString to a String

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s = GString::from(S);

assert_eq!(s, S.to_string());
assert_ne!(s, String::new());

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 GString

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

Compare two GStrings

use gstring::*;

const S: &str = "a\u{310}e\u{301}o\u{308}\u{332}";

let s1 = GString::from(S);
let s2 = GString::from(S);
let s3 = GString::from(S);

assert_eq!(s1, s2);
assert_ne!(s3, GString::from(""));

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 Serialize for GString

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.