Enum Segment

pub enum Segment<'a> {
    Plain {
        text: &'a str,
    },
    Rubied {
        text: &'a str,
        ruby: &'a str,
    },
}

A part of a RubyString that either has no ruby glosses or exactly one ruby gloss attached to it. This type appears:

• when iterating over the segments of a RubyStrings using its segments method, or
• when extend()ing a RubyString using an impl Iterator<Item = Segment>,
• when building a RubyString through collect() on an impl Iterator<Item = Segment>.

Variants

Plain

A piece of text that does not have any ruby glosses attached to it.

Fields

text: &'a str

Rubied

A piece of text that has exactly one ruby gloss attached to its entirety.

Fields

text: &'a str

ruby: &'a str

Implementations

impl<'a> Segment<'a>

pub fn plain_text(&self) -> &'a str

Returns only the plain text in this segment, ignoring any ruby glosses attached to it.

pub fn to_interlinear_encoding(&self) -> String

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

let s = Segment::Plain { text: "です" };
assert_eq!(s.to_interlinear_encoding(), "です");
let s = Segment::Rubied { text: "東京", ruby: "とうきょう" };
assert_eq!(s.to_interlinear_encoding(), "\u{FFF9}東京\u{FFFA}とうきょう\u{FFFB}");

Trait Implementations

impl<'a> Clone for Segment<'a>

fn clone(&self) -> Segment<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Segment<'a>

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

Formats the value using the given formatter.

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<'a> FromIterator<Segment<'a>> for RubyString

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

Creates a value from an iterator.

impl<'a> PartialEq for Segment<'a>

fn eq(&self, other: &Segment<'a>) -> 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<'a> Copy for Segment<'a>

impl<'a> Eq for Segment<'a>

impl<'a> StructuralPartialEq for Segment<'a>