Enum Language 

#[repr(u8)]
pub enum Language {
    Auto = 0,
    Arabic = 1,
    Chinese = 2,
    English = 3,
    Esperanto = 4,
    Finnish = 5,
    French = 6,
    German = 7,
    Greek = 8,
    Hebrew = 9,
    Hindi = 10,
    Indonesian = 11,
    Korean = 12,
    Portuguese = 13,
    Romanian = 14,
    Russian = 15,
    Spanish = 16,
    Tagalog = 17,
    Vietnamese = 18,
}

A language understood by the reference parser.

Language::Auto searches all bundled languages. The remaining variants represent concrete languages, including languages for which callers may register their own aliases even when this crate does not bundle book names.

Variants

Auto = 0

Search every language with bundled book aliases.

Arabic = 1

Arabic (ar).

Chinese = 2

Chinese (zh).

English = 3

English (en).

Esperanto = 4

Esperanto (eo), available for custom aliases.

Finnish = 5

Finnish (fi), available for custom aliases.

French = 6

French (fr).

German = 7

German (de).

Greek = 8

Greek (el), available for custom aliases.

Hebrew = 9

Hebrew (he).

Hindi = 10

Hindi (hi).

Indonesian = 11

Indonesian (id).

Korean = 12

Korean (ko).

Portuguese = 13

Portuguese (pt).

Romanian = 14

Romanian (ro), available for custom aliases.

Russian = 15

Russian (ru).

Spanish = 16

Spanish (es).

Tagalog = 17

Tagalog (tl).

Vietnamese = 18

Vietnamese (vi), available for custom aliases.

Implementations

impl Language

pub const ALL: [Language; 19]

Every language and parser mode, in stable declaration order.

pub const SUPPORTED: [Language; 14]

Languages and parser modes backed by bundled book aliases.

pub const fn display_name(self) -> &'static str

The human-readable English name of this language.

pub const fn code(self) -> &'static str

The canonical ISO 639-1 code, or "auto" for auto-detection.

pub const fn identifier_prefix(self) -> &'static str

The ISO 639-2 identifier accepted for this language.

pub const fn aliases(self) -> &'static [&'static str]

Supplemental identifiers in addition to the name and ISO codes.

pub fn all_aliases(self) -> impl Iterator<Item = &'static str>

Every accepted identifier for this language.

This includes the lowercase variant name, display name, two-letter code, three-letter identifier, and supplemental aliases.

pub const fn is_parsing_supported(self) -> bool

Whether the crate bundles parsing aliases for this language or mode.

pub const fn is_auto(self) -> bool

Whether this is the auto-detection parser mode rather than a language.

Trait Implementations

impl AsRef<str> for Language

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Language

fn clone(&self) -> Language

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Language

impl Debug for Language

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

Formats the value using the given formatter.

impl Default for Language

fn default() -> Language

Returns the “default value” for a type.

impl Display for Language

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

Formats the value using the given formatter.

impl Eq for Language

impl From<Language> for ReferenceFormatter

fn from(language: Language) -> ReferenceFormatter

Converts to this type from the input type.

impl FromStr for Language

type Err = ParseLanguageError

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Language, <Language as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Language

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Language

fn cmp(&self, other: &Language) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Language

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Language

fn partial_cmp(&self, other: &Language) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Language

impl TryFrom<&str> for Language

type Error = ParseLanguageError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Language, <Language as TryFrom<&str>>::Error>

Performs the conversion.