Struct hyphenation::extended::Extended

pub struct Extended {
    pub exceptions: Exceptions,
    pub minima: (usize, usize),
    // some fields omitted
}

A dictionary for extended Knuth–Liang hyphenation, based on the strategy described by Németh in "Automatic non-standard hyphenation in OpenOffice.org".

It comprises the working language, the set of extended patterns and exceptions, and the character boundaries for hyphenation.

Fields

exceptions: Exceptions

minima: (usize, usize)

The minimum number of chars from the start and end of a word where breaks may not occur.

Implementations

impl Extended

pub fn language(&self) -> Language

The language for which this dictionary can provide hyphenation.

pub fn prefix_tallies(&'f self, query: &'q [u8]) -> PrefixTallies<'f, 'q, Tally>

An iterator over the tallies associated to all prefixes of the query, including the query itself.

Trait Implementations

impl Debug for Extended

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Extended

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Extended, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<Builder> for Extended

fn from(b: Builder) -> Extended

Performs the conversion.

impl<'h> Hyphenator<'h> for Extended

type Opportunity = (usize, Option<&'h Subregion>)

Plain representation of a word break.

type Exact = (usize, Option<Subregion>)

An owned opportunity used to specify and store the predetermined hyphenation of known words.

fn hyphenate<'t>(&'h self, word: &'t str) -> Word<'t, Self::Opportunity>

Hyphenate a word, computing appropriate word breaks and preparing it for iteration.

fn opportunities_within(
    &'h self,
    word: &str,
    (l, r): (usize, usize)
) -> Vec<Self::Opportunity>

The hyphenation opportunities that arise by pattern between the specified byte indices.

fn exception_within(
    &'h self,
    w: &str,
    (l, r): (usize, usize)
) -> Option<Vec<Self::Opportunity>>

The hyphenation opportunities that arise by exception between the specified byte indices, if any.

fn add_exception(
    &mut self,
    w: String,
    ops: Vec<Self::Exact>
) -> Option<Vec<Self::Exact>>

Specify the hyphenation of the given word with an exact sequence of opportunities and add it to the exception list. Subsequent calls to hyphenate or opportunities will yield this hyphenation instead of generating one from patterns.

fn remove_exception(&mut self, w: &str) -> Option<Vec<Self::Exact>>

If the word is an exception, remove it and return the previously specified opportunities; otherwise, return none.

fn unbreakable_chars(&self) -> (usize, usize)

The number of chars from the start and end of a word where breaks may not occur, according to dictionary parameters.

fn opportunities(&'h self, lowercase_word: &str) -> Vec<Self::Opportunity>

The hyphenation opportunities that our dictionary can find in the given word. The word should be lowercase.

fn exception(&'h self, lowercase_word: &str) -> Option<Vec<Self::Opportunity>>

If this word is a known exception, retrieve its specified hyphenation.

fn boundaries(&self, word: &str) -> Option<(usize, usize)>

The byte indices delimiting the substring where breaks may occur, unless the word is too short to be hyphenated.

impl Load for Extended

fn from_reader<R>(lang: Language, reader: &mut R) -> Result<Self> where
    R: Read, 

Deserialize a dictionary from the provided reader, verifying that it belongs to the expected language.

fn any_from_reader<R>(reader: &mut R) -> Result<Self> where
    R: Read, 

Deserialize a dictionary from the provided reader.

fn from_path<P>(lang: Language, path: P) -> Result<Self> where
    P: AsRef<Path>, 

Read and deserialize the dictionary at the given path, verifying that it belongs to the expected language.

impl<'d> Score<'d> for Extended

type Value = (u8, Option<&'d Subregion>)

A value assigned to each index — which is to say, to each potential break between letters — to determine whether the string can be broken at that index.

fn denotes_opportunity((v, _): Self::Value) -> bool

Whether the given value denotes a valid break.

fn score(&'d self, word: &str) -> Vec<Self::Value>

Generate a word's hyphenation score, from which opportunities may be extracted.

impl Serialize for Extended

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

Serialize this value into the given Serde serializer.