Enum LanguageCode

pub enum LanguageCode {
    ab,
    aa,
    af,
    ak,
    sq,
    am,
    ar,
    an,
    hy,
    as,
    av,
    ae,
    ay,
    az,
    bm,
    ba,
    eu,
    be,
    bn,
    bi,
    bs,
    br,
    bg,
    my,
    ca,
    ch,
    ce,
    ny,
    zh,
    cu,
    cv,
    kw,
    co,
    cr,
    hr,
    cs,
    da,
    dv,
    nl,
    dz,
    en,
    eo,
    et,
    ee,
    fo,
    fj,
    fi,
    fr,
    fy,
    ff,
    gd,
    gl,
    lg,
    ka,
    de,
    el,
    kl,
    gn,
    gu,
    ht,
    ha,
    he,
    hz,
    hi,
    ho,
    hu,
    is,
    io,
    ig,
    id,
    ia,
    ie,
    iu,
    ik,
    ga,
    it,
    ja,
    jv,
    kn,
    kr,
    ks,
    kk,
    km,
    ki,
    rw,
    ky,
    kv,
    kg,
    ko,
    kj,
    ku,
    lo,
    la,
    lv,
    li,
    ln,
    lt,
    lu,
    lb,
    mk,
    mg,
    ms,
    ml,
    mt,
    gv,
    mi,
    mr,
    mh,
    mn,
    na,
    nv,
    nd,
    nr,
    ng,
    ne,
    no,
    nb,
    nn,
    ii,
    oc,
    oj,
    or,
    om,
    os,
    pi,
    ps,
    fa,
    pl,
    pt,
    pa,
    qu,
    ro,
    rm,
    rn,
    ru,
    se,
    sm,
    sg,
    sa,
    sc,
    sr,
    sn,
    sd,
    si,
    sk,
    sl,
    so,
    st,
    es,
    su,
    sw,
    ss,
    sv,
    tl,
    ty,
    tg,
    ta,
    tt,
    te,
    th,
    bo,
    ti,
    to,
    ts,
    tn,
    tr,
    tk,
    tw,
    ug,
    uk,
    ur,
    uz,
    ve,
    vi,
    vo,
    wa,
    cy,
    wo,
    xh,
    yi,
    yo,
    za,
    zu,
    Other(Box<str>),
}

Variants

ab

aa

af

ak

sq

am

ar

an

hy

as

av

ae

ay

az

bm

ba

eu

be

bn

bi

bs

br

bg

my

ca

ch

ce

ny

zh

cu

cv

kw

co

cr

hr

cs

da

dv

nl

dz

en

eo

et

ee

fo

fj

fi

fr

fy

ff

gd

gl

lg

ka

de

el

kl

gn

gu

ht

ha

he

hz

hi

ho

hu

is

io

ig

id

ia

ie

iu

ik

ga

it

ja

jv

kn

kr

ks

kk

km

ki

rw

ky

kv

kg

ko

kj

ku

lo

la

lv

li

ln

lt

lu

lb

mk

mg

ms

ml

mt

gv

mi

mr

mh

mn

na

nv

nd

nr

ng

ne

no

nb

nn

ii

oc

oj

or

om

os

pi

ps

fa

pl

pt

pa

qu

ro

rm

rn

ru

se

sm

sg

sa

sc

sr

sn

sd

si

sk

sl

so

st

es

su

sw

ss

sv

tl

ty

tg

ta

tt

te

th

bo

ti

to

ts

tn

tr

tk

tw

ug

uk

ur

uz

ve

vi

vo

wa

cy

wo

xh

yi

yo

za

zu

Other(Box<str>)

Implementations

impl LanguageCode

pub const VARS: &'static [LanguageCode]

Trait Implementations

impl Clone for LanguageCode

fn clone(&self) -> LanguageCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LanguageCode

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

Formats the value using the given formatter.

impl Default for LanguageCode

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LanguageCode

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LanguageCode

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

Formats the value using the given formatter.

impl FromStr for LanguageCode

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for LanguageCode

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

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<'a> PartialEq<&'a str> for LanguageCode

fn eq(&self, other: &&'a str) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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> PartialEq<Cow<'a, str>> for LanguageCode

fn eq(&self, other: &Cow<'a, str>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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> PartialEq<String> for LanguageCode

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

Tests for self and other values to be equal, and is used by ==.

const 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> PartialEq<str> for LanguageCode

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

Tests for self and other values to be equal, and is used by ==.

const 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 PartialEq for LanguageCode

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

Tests for self and other values to be equal, and is used by ==.

const 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 Serialize for LanguageCode

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LanguageCode