Struct Rulebook 

pub struct Rulebook<A = ()> {
    pub rules: FnRules,
    pub owned_values: A,
}

A set of rules that govern how LocaleFallbackSolver should handle fallbacks.

For the thread-safe version, see ARulebook<A>.

Rulebook<A>, regardless of type A, stores the rules as FnRules, a vector of boxed dyn Fn(&LanguageIdentifier) -> Vec<LanguageIdentifier>. Therefore, the actual correct name of this struct should be something along the lines of FnsRulebook.

Obviously this rulebook can be used with the solver because it implements PolyL10nRulebook.

In addition, the default rulebook Rulebook::default() can and probably should be used for most situations you ever need to deal with.

Fields

rules: FnRules

owned_values: A

Implementations

impl Rulebook<Rc<Vec<Rulebook>>>

pub fn from_rulebooks<I: Iterator<Item = Rulebook>>(rulebooks: I) -> Self

Combine multiple rulebooks into one.

See also: Self::from_ref_rulebooks.

Examples

let rb1 = poly_l10n::Rulebook::from_fn(|l| {
  let mut l = l.clone();
  l.script = None;
  vec![l]
});
let rb2 = poly_l10n::Rulebook::from_fn(|l| {
  let mut l = l.clone();
  l.region = None;
  vec![l]
});
let rulebook = poly_l10n::Rulebook::from_rulebooks([rb1, rb2].into_iter());
let solv = poly_l10n::LocaleFallbackSolver { rulebook };

assert_eq!(
  solv.solve_locale(poly_l10n::langid!["zh-Hant-HK"]),
  poly_l10n::langid!["zh-HK", "zh-Hant", "zh"]
);

impl<RR, R> Rulebook<(Rc<Vec<RR>>, PhantomData<R>)>

where RR: AsRef<Rulebook<R>> + 'static,

pub fn from_ref_rulebooks<I: Iterator<Item = RR>>(rulebooks: I) -> Self

Combine multiple rulebooks into one. Each given rulebook r must implement AsRef::as_ref.

For the owned version, see Self::from_rulebooks.

Examples

let rb1 = poly_l10n::Rulebook::from_fn(|l| {
  let mut l = l.clone();
  l.script = None;
  vec![l]
});
let rb2 = poly_l10n::Rulebook::from_fn(|l| {
  let mut l = l.clone();
  l.region = None;
  vec![l]
});
let (rb1, rb2) = (Rc::new(rb1), Rc::new(rb2));
let rulebook = poly_l10n::Rulebook::from_ref_rulebooks([rb1, rb2].iter().cloned());
let solv = poly_l10n::LocaleFallbackSolver { rulebook };

assert_eq!(
  solv.solve_locale(poly_l10n::langid!["zh-Hant-HK"]),
  poly_l10n::langid!["zh-HK", "zh-Hant", "zh"]
);

impl Rulebook

pub fn from_fn<F: Fn(&LanguageIdentifier) -> Vec<LanguageIdentifier> + 'static>( f: F, ) -> Self

pub const fn from_fns(rules: FnRules) -> Self

pub fn from_map<M, LS>(map: M) -> Self

where M: for<'a> Index<&'a LanguageIdentifier, Output = LS> + 'static, for<'b> &'b LS: IntoIterator<Item = &'b LanguageIdentifier>,

Convert a map (or anything that impl std::ops::Index<&LanguageIdentifier>) into a rulebook.

The output of the map must implement IntoIterator<Item = &LanguageIdentifier>.

While any valid arguments to this constructor are guaranteed to satisfy the trait PolyL10nRulebook, it could be useful to convert them to rulebooks, e.g. to combine multiple rulebooks using Self::from_rulebooks.

Trait Implementations

impl<A: Debug> Debug for Rulebook<A>

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

Formats the value using the given formatter.

impl Default for Rulebook

fn default() -> Self

Returns the “default value” for a type.

impl<A> PolyL10nRulebook<'_> for Rulebook<A>

fn find_fallback_locale( &self, locale: &LanguageIdentifier, ) -> impl Iterator<Item = LanguageIdentifier>

fn find_fallback_locale_ref( &'s self, _: &LanguageIdentifier, ) -> impl Iterator<Item = &'s LanguageIdentifier>