Enum TagLanguageId 

pub enum TagLanguageId {
    Afrikaans,
    Albanian,
    Arabic,
    Aramaic,
    Armenian,
    Bengali,
    Bosnian,
    Bulgarian,
    Burmese,
    Catalan,
    Cebuano,
    Chinese,
    Cree,
    Creole,
    Croatian,
    Czech,
    Danish,
    Dutch,
    English,
    Esperanto,
    Estonian,
    Finnish,
    French,
    Georgian,
    German,
    Greek,
    Gujarati,
    Hebrew,
    Hindi,
    Hmong,
    Hungarian,
    Icelandic,
    Indonesian,
    Irish,
    Italian,
    Japanese,
    Javanese,
    Kannada,
    Kazakh,
    Khmer,
    Korean,
    Kurdish,
    Ladino,
    Lao,
    Latin,
    Latvian,
    Marathi,
    Mongolian,
    Ndebele,
    Nepali,
    Norwegian,
    Oromo,
    Papiamento,
    Pashto,
    Persian,
    Polish,
    Portuguese,
    Punjabi,
    Romanian,
    Russian,
    Sango,
    Sanskrit,
    Serbian,
    Shona,
    Slovak,
    Slovenian,
    Somali,
    Spanish,
    Swahili,
    Swedish,
    Tagalog,
    Tamil,
    Telugu,
    Thai,
    Tibetan,
    Tigrinya,
    Turkish,
    Ukrainian,
    Urdu,
    Vietnamese,
    Welsh,
    Yiddish,
    Zulu,
}

Variants

Afrikaans

Albanian

Arabic

Aramaic

Armenian

Bengali

Bosnian

Bulgarian

Burmese

Catalan

Cebuano

Chinese

Cree

Creole

Croatian

Czech

Danish

Dutch

English

Esperanto

Estonian

Finnish

French

Georgian

German

Greek

Gujarati

Hebrew

Hindi

Hmong

Hungarian

Icelandic

Indonesian

Irish

Italian

Japanese

Javanese

Kannada

Kazakh

Khmer

Korean

Kurdish

Ladino

Lao

Latin

Latvian

Marathi

Mongolian

Ndebele

Nepali

Norwegian

Oromo

Papiamento

Pashto

Persian

Polish

Portuguese

Punjabi

Romanian

Russian

Sango

Sanskrit

Serbian

Shona

Slovak

Slovenian

Somali

Spanish

Swahili

Swedish

Tagalog

Tamil

Telugu

Thai

Tibetan

Tigrinya

Turkish

Ukrainian

Urdu

Vietnamese

Welsh

Yiddish

Zulu

Trait Implementations

impl Clone for TagLanguageId

fn clone(&self) -> TagLanguageId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TagLanguageId

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

Formats the value using the given formatter.

impl Deserialize for TagLanguageId

fn begin(__out: &mut Option<Self>) -> &mut dyn Visitor

The only correct implementation of this method is:

impl PartialEq for TagLanguageId

fn eq(&self, other: &TagLanguageId) -> 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<'a_, C_: Context> Readable<'a_, C_> for TagLanguageId

fn read_from<R_: Reader<'a_, C_>>(_reader_: &mut R_) -> Result<Self, C_::Error>

fn minimum_bytes_needed() -> usize

fn read_from_buffer(buffer: &'a [u8]) -> Result<Self, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

Deserializes from a given buffer.

fn read_with_length_from_buffer( buffer: &'a [u8], ) -> (Result<Self, <C as Context>::Error>, usize)

where Self: DefaultContext<Context = C>, C: Default,

Deserializes from a given buffer while also returning the amount of bytes consumed.

fn read_from_buffer_copying_data( buffer: &[u8], ) -> Result<Self, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

Deserializes from a given buffer.

fn read_with_length_from_buffer_copying_data( buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)

where Self: DefaultContext<Context = C>, C: Default,

Deserializes from a given buffer while also returning the amount of bytes consumed.

fn read_from_stream_unbuffered( stream: impl Read, ) -> Result<Self, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

Reads from a given stream without any buffering.

fn read_from_stream_buffered( stream: impl Read, ) -> Result<Self, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

Reads from a given stream with internal buffering.

fn read_from_file(path: impl AsRef<Path>) -> Result<Self, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

fn read_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut( context: &mut C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>( context: C, stream: S, ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_stream_buffered_with_ctx<S>( context: C, stream: S, ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_file_with_ctx( context: C, path: impl AsRef<Path>, ) -> Result<Self, <C as Context>::Error>

impl Serialize for TagLanguageId

fn begin(&self) -> Fragment<'_>

impl<C_: Context> Writable<C_> for TagLanguageId

fn write_to<T_: ?Sized + Writer<C_>>( &self, _writer_: &mut T_, ) -> Result<(), C_::Error>

fn write_to_buffer( &self, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

fn write_to_vec(&self) -> Result<Vec<u8>, <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

fn write_to_stream<S>(&self, stream: S) -> Result<(), <C as Context>::Error>

where S: Write, Self: DefaultContext<Context = C>, C: Default,

fn write_to_file( &self, path: impl AsRef<Path>, ) -> Result<(), <C as Context>::Error>

where Self: DefaultContext<Context = C>, C: Default,

fn write_to_buffer_with_ctx( &self, context: C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut( &self, context: &mut C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx( &self, context: C, ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut( &self, context: &mut C, ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>( &self, context: C, stream: S, ) -> Result<(), <C as Context>::Error>

where S: Write,

fn write_to_file_with_ctx( &self, context: C, path: impl AsRef<Path>, ) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Copy for TagLanguageId

impl Eq for TagLanguageId

impl StructuralPartialEq for TagLanguageId