Struct RubyString

pub struct RubyString { /* private fields */ }

A string type that can have ruby glosses attached to parts of it.

Memory layout

The text content is stored in two String instances, one being the main text and one being a concatenation of all the rubies. Placement of the rubies is stored as a list of indices into both strings. Compared to the trivial structure (where each rubied substring is held as a separate String), this layout reduces memory usage and the number of separate allocations at the expense of slightly more complicated indexing logic.

Implementations

impl RubyString

pub fn new() -> RubyString

Creates a new empty RubyString.

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

Appends plain text (that does not have a ruby gloss attached to it) to this RubyString.

pub fn push_segment<'a>(&mut self, segment: Segment<'a>)

Appends text to this RubyString and attaches a ruby gloss to it.

pub fn to_plain_text(&self) -> String

Returns the plain text stored in this RubyString. The result has no ruby glosses attached to it anymore.

let mut rs = RubyString::new();
rs.push_str("ここは");
rs.push_segment(Segment::Rubied { text: "東", ruby: "とう" });
rs.push_segment(Segment::Rubied { text: "京", ruby: "きょう" });
rs.push_str("です");
assert_eq!(rs.to_plain_text(), "ここは東京です");

pub fn to_interlinear_encoding(&self) -> String

Returns an encoding of this RubyString as a plain String using interlinear annotation characters.

let mut rs = RubyString::new();
rs.push_str("ここは");
rs.push_segment(Segment::Rubied { text: "東", ruby: "とう" });
rs.push_segment(Segment::Rubied { text: "京", ruby: "きょう" });
rs.push_str("です");
let encoded = rs.to_interlinear_encoding();
assert_eq!(encoded, "ここは\u{FFF9}東\u{FFFA}とう\u{FFFB}\u{FFF9}京\u{FFFA}きょう\u{FFFB}です");

pub fn segments(&self) -> SegmentIterator<'_>

An iterator over the segments in this RubyString.

Trait Implementations

impl Clone for RubyString

fn clone(&self) -> RubyString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for RubyString

fn default() -> Self

Returns the “default value” for a type.

impl<'a> Extend<Segment<'a>> for RubyString

fn extend<I: IntoIterator<Item = Segment<'a>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: Into<String>> From<T> for RubyString

fn from(val: T) -> RubyString

Converts to this type from the input type.

impl<'a> FromIterator<Segment<'a>> for RubyString

fn from_iter<I: IntoIterator<Item = Segment<'a>>>(iter: I) -> RubyString

Creates a value from an iterator.

impl PartialEq for RubyString

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

impl StructuralPartialEq for RubyString