Struct Translator 

pub struct Translator { /* private fields */ }

A lightweight, request-scoped translation helper.

Translator stores an interned locale identifier and forwards lookups to the global Lang store without mutating the process-wide active locale. This makes it a good fit for web handlers, jobs, and other code paths where locale is part of the input rather than part of global application state.

Cloning a Translator is cheap — the locale is held as a &'static str, so the operation is a pointer copy and no allocation occurs.

Examples

use lang_lib::{Lang, Translator};

Lang::load_from("en", "tests/fixtures/locales").unwrap();
let translator = Translator::new("en");

let title = translator.translate_with_fallback("welcome", "Welcome");
assert_eq!(title, "Welcome");

Implementations

impl Translator

pub fn new(locale: impl AsRef<str>) -> Self

Creates a translator bound to a specific locale.

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

Returns the locale used by this translator.

pub fn translate<'a>(&self, key: &'a str) -> Cow<'a, str>

Translates a key using this translator’s locale.

The returned value borrows directly into the interned translation store on the hit path and into key on the complete-miss path. Both outcomes are zero-allocation.

pub fn translate_with_fallback<'a>( &self, key: &'a str, fallback: &'a str, ) -> Cow<'a, str>

Translates a key using this translator’s locale and an inline fallback.

The returned value borrows directly into the interned translation store on the hit path, into fallback when the lookup misses, and into key only if no fallback resolves either. All three outcomes are zero-allocation.

Trait Implementations

impl Clone for Translator

fn clone(&self) -> Translator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Translator

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

Formats the value using the given formatter.

impl PartialEq for Translator

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

impl Eq for Translator

impl StructuralPartialEq for Translator