Struct Language 

pub struct Language {
    pub id: &'static LanguageIdentifier,
    pub name: &'static str,
    pub dir: &'static WritingDirection,
    pub flag: Option<&'static str>,
}

Each language supported by your application.

Fields

id: &'static LanguageIdentifier

Language identifier

Can be any valid language tag, such as en, es, en-US, es-ES, etc.

name: &'static str

Language name

The name of the language, such as English, Español, etc. This name will be intended to be displayed in the language selector.

dir: &'static WritingDirection

Writing direction of the language

flag: Option<&'static str>

Flag of the country of the language as emoji (if any)

Implementations

impl Language

pub fn is_active(&'static self) -> bool

👎Deprecated since 0.2.13: will be removed in v0.3.0. Use &i18n.language.get() == lang instead of lang.is_active().

Get if the language is the active language.

pub fn activate(&'static self)

👎Deprecated since 0.2.13: will be removed in v0.3.0. Use &i18n.language.set(lang) instead of lang.activate().

Set the language as the active language.

Trait Implementations

impl AttributeValue for &Language

type State = <String as AttributeValue>::State

The state that should be retained between building and rebuilding.

type AsyncOutput = String

The type once all async data have loaded.

type Cloneable = String

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

type CloneableOwned = String

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> Self::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build(self, el: &Element, key: &str) -> Self::State

Adds this attribute to the element during client-side rendering.

fn rebuild(self, key: &str, state: &mut Self::State)

Applies a new value for the attribute.

fn into_cloneable(self) -> Self::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned(self) -> Self::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> Self::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

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 Debug for Language

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

Formats the value using the given formatter.

impl FromStr for Language

type Err = ()

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 Language

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, Inner> PartialEq<ReadGuard<&'a Language, Inner>> for &Language

where Inner: Deref<Target = &'a Language>,

fn eq(&self, other: &ReadGuard<&'a Language, Inner>) -> 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 PartialEq for Language

fn eq(&self, other: &Self) -> 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 Eq for Language