Struct kl_hyphenate::Standard

pub struct Standard {
    pub language: Language,
    pub patterns: Patterns,
    pub exceptions: Exceptions,
    pub minima: (usize, usize),
}

A dictionary for standard Knuth–Liang hyphenation.

It comprises the working language, the pattern and exception sets, and the character boundaries for hyphenation.

Fields

language: Language

patterns: Patterns

exceptions: Exceptions

minima: (usize, usize)

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

Trait Implementations

impl Clone for Standard

fn clone(&self) -> Standard

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Standard

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Standard

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

Deserialize this value from the given Serde deserializer.

impl Eq for Standard

impl<'h> Hyphenator<'h> for Standard

type Opportunity = usize

Plain representation of a word break.

type Exact = usize

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

The hyphenation opportunities that arise between the specified indices.

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

Retrieve the known exact hyphenation for this word, if any, between the specified indices.

fn add_exact(&mut self, w: String, ops: Vec<usize>) -> Option<Vec<usize>>

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

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

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

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 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 Standard

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

Deserialize a dictionary from the provided reader, verifying that it effectively belongs to the requested 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 effectively belongs to the requested language.

impl PartialEq<Standard> for Standard

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Standard) -> bool

This method tests for !=.

impl<'d> Score<'d> for Standard

type Value = u8

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<u8>

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

impl Serialize for Standard

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.

impl StructuralEq for Standard

impl StructuralPartialEq for Standard