Enum FormatType 

pub enum FormatType {
    AndroidStrings(Option<String>),
    Strings(Option<String>),
    Xcstrings,
    CSV,
    TSV,
}

Represents all supported localization file formats for generic handling.

This enum allows you to work with any supported file format in a type-safe way.

Variants

AndroidStrings(Option<String>)

Android strings.xml format, with optional language code.

Strings(Option<String>)

Apple .strings format, with optional language code.

Xcstrings

Apple .xcstrings format (no language code).

CSV

CSV format (multi-language support built-in).

TSV

TSV format (multi-language support built-in).

Implementations

impl FormatType

pub fn extension(&self) -> &'static str

Returns the typical file extension for this format.

pub fn language(&self) -> Option<&String>

Returns the language code for this format, if available.

pub fn with_language(&self, lang: Option<String>) -> Self

Recreates the format type with a new language code, if applicable.

pub fn matches_language_of(&self, other: &FormatType) -> bool

Checks if this format matches the language of another format.

For Xcstrings, it always returns true since it has no language and matches any other Xcstrings. Note that this does not look at the actual content of the files, only the format type and its language. So if the the xcstrings file does not have that language, it will still return true.

Example

use langcodec::formats::FormatType;
let format1 = FormatType::AndroidStrings(Some("en".to_string()));
let format2 = FormatType::AndroidStrings(Some("en".to_string()));
let format3 = FormatType::Strings(Some("fr".to_string()));
let format4 = FormatType::Xcstrings;

assert!(format1.matches_language_of(&format2));
assert!(!format1.matches_language_of(&format3));
assert!(format4.matches_language_of(&format4));
assert!(format4.matches_language_of(&format1));

This is useful for ensuring that two formats can be compared or converted without language mismatch issues.

Trait Implementations

impl Clone for FormatType

fn clone(&self) -> FormatType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FormatType

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

Formats the value using the given formatter.

impl Display for FormatType

Implements std::fmt::Display for FormatType.

This provides a human-friendly string for each format type:

• AndroidStrings(_) → "android"
• Strings(_) → "strings"
• Xcstrings → "xcstrings"

Example

use langcodec::formats::FormatType;
use std::fmt::Display;
assert_eq!(FormatType::AndroidStrings(None).to_string(), "android");
assert_eq!(FormatType::Strings(None).to_string(), "strings");
assert_eq!(FormatType::Xcstrings.to_string(), "xcstrings");

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

Formats the value using the given formatter.

impl FromStr for FormatType

Implements std::str::FromStr for FormatType.

Accepts the following case-insensitive strings:

• "android", "androidstrings", "xml" → FormatType::AndroidStrings(None)
• "strings" → FormatType::Strings(None)
• "xcstrings" → FormatType::Xcstrings

Returns crate::error::Error::UnknownFormat for unknown strings.

Example

use langcodec::formats::FormatType;
use std::str::FromStr;
assert_eq!(FormatType::from_str("android").unwrap(), FormatType::AndroidStrings(None));
assert_eq!(FormatType::from_str("strings").unwrap(), FormatType::Strings(None));
assert_eq!(FormatType::from_str("xcstrings").unwrap(), FormatType::Xcstrings);
assert!(FormatType::from_str("foobar").is_err());

type Err = Error

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 PartialEq for FormatType

fn eq(&self, other: &FormatType) -> 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 FormatType

impl StructuralPartialEq for FormatType