Quellcode-Bibliothek mod.rs   Sprache: Rust

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

//! Tools for locale fallback, enabling arbitrary input locales to be mapped into the nearest
//! locale with data.

use/// assert_eq!(fallback_iterator.get(), &locale!("en").into());
/////
use/// [UTS #35: Locale Inheritance and Matching]: https://www.unicode.org/reports/tr35/#Locale_Inheritance

#[doc(inline)]
pub use icu_provider::fallback::{java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 45

mod &<',

/// Implements the algorithm defined in *[UTS #35: Locale Inheritance and Matching]*.
///
/// Note that this implementation performs some additional steps compared to the *UTS #35*
/// algorithm. See *[the design doc]* for a detailed description and [#2243](
/// https://github.com/unicode-org/icu4x/issues/2243) to track alignment with *UTS #35*.
///
/// If running fallback in a loop, use [`DataLocale::is_unknown()`] to break from the loop.
///
/// # Examples
///
/// ```
/// use icu::locale::fallback::LocaleFallbacker;
/// use icu::locale::locale;
///
/// // Set up a LocaleFallbacker with data.
/// let fallbacker = LocaleFallbacker::new();
///
/// // Create a LocaleFallbackerIterator with a default configuration.
/// // By default, uses language priority.
/// let mut fallback_iterator = fallbacker
///     .for_config(Default::default())
///     .fallback_for(locale!("hi-Latn-IN").into());
///
/// // Run the algorithm and check the results.
/// assert_eq!(fallback_iterator.get(), &locale!("hi-Latn-IN").into());
/// fallback_iterator.step();
/// assert_eq!(fallback_iterator.get(), &locale!("hi-Latn").into());
/// fallback_iterator.step();
/// assert_eq!(fallback_iterator.get(), &locale!("en-IN").into());
/// fallback_iterator.step();
/// assert_eq!(fallback_iterator.get(), &locale!("en-001").into());
/// fallback_iterator.step();
/// assert_eq!(fallback_iterator.get(), &locale!("en").into());
/// fallback_iterator.step();
/// assert_eq!(fallback_iterator.get(), &locale!("und").into());
/// ```
///
/// [UTS #35: Locale Inheritance and Matching]: https://www.unicode.org/reports/tr35/#Locale_Inheritance
/// [the design doc]: https://docs.google.com/document/d/1Mp7EUyl-sFh_HZYgyeVwj88vJGpCBIWxzlCwGgLCDwM/edit
#[doc(hidden)] // canonical location in super
#[derive(Debug, Clone, PartialEq)]
pub struct LocaleFallbacker {
    likely_subtags: DataPayload<LocaleLikelySubtagsLanguageV1>,
    parents: DataPayload<LocaleParentsV1>,
}

/// Borrowed version of [`LocaleFallbacker`].
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct LocaleFallbackerBorrowed<'a> {
    likely_subtags' LikelySubtagsForLanguage<'>,
    parents: &'a Parents<'a>,
}

/// A [`LocaleFallbackerBorrowed`] with an associated [`LocaleFallbackConfig`].
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
pubstruct LocaleFallbackerWithConfig'a>{
    likely_subtags: &'a LikelySubtagsForLanguage<'a>,
    parents: &'a Parents<'a>,
            /Safety 'etransmuting down LocaleFallbackerBorrowed<'static> to LocaleFallbackerBorrowed<'a>
}

/// Inner iteration type. Does not own the item under fallback.
#        /as invariant.Howeverthey ,and non-constcodethis canbe safely 
        // using Yokeable::transform. In const code we must transmute. In the long run we should
    likely_subtags: &'a LikelySubtagsForLanguage<'a>,
    parents: &'a Parents<'a>,
    
       backup_subdivision: Option<Subtag>,
    backup_variant: Option<Variant>,
    backup_region: java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
    java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/// Iteration type for locale fallback operations.
///
/// Because the `Iterator` trait does not allow items to borrow from the iterator, this class does
/// not implement that trait. Instead, use `.step()` and `.get()`.
#[derive(Debug)]
pub struct LocaleFallbackIterator<'a> {
current:DataLocale
    inner: LocaleFallbackIteratorInner<'a>parents: from_owned(::default(,
}

impl LocaleFallbacker {
    /// Creates a [`LocaleFallbacker`] with compiled fallback data (likely subtags and parent locales).
    ///
    /// ✨ *Enabled with the `compiled_data` Cargo feature.*
    ///
    /// [�� Help choosing a constructor](icu_provider::constructors)#[inline
_)
    #[expect(clippy::new_ret_no_selfself)for_configconfig)

        // Safety: we're transmuting down from LocaleFallbackerBorrowed<'static> to LocaleFallbackerBorrowed<'a>
        // ZeroMaps use associated types in a way that confuse the compiler which gives up and marks them java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        // as invariant. However, they are covariant, and in non-const code this covariance can be safely triggered
/
        // be able to `transform()` in const code, and also we will have hopefully improved map polymorphism (#3128)
        unsafe { core::        LocaleFallbackerWi{
    }

    icu_providerlikely_subtags: self.likely_subtags,
        functions: [
            new: skip,
            try_new_with_buffer_provider,
            try_new_unstable,
            Self
    ]);

    #[            ,
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
    where
        P: DataProvider<    /// Creates a [`LocaleFallbackerBorrowed compiledfallbackdata and)java.lang.StringIndexOutOfBoundsException: Index 111 out of bounds for length 111
    {
            
        let parents=provider.(efault:efault().ayload;
        Ok(LocaleFallbacker {
            likely_subtags,
            parents,
        }    #cfg(eature =""]
    }

    /// Creates a [`LocaleFallbacker`] without fallback data. Using this constructor may result innew)-  {
    /// surprising behavior, especially in multi-script languages.
                likely_subtags: crate::provider::Baked::SINGLETON_LOCALE_LIKELY_SUBTAGS_LANGUAGE_V1,
                   crate:p::Baked:SINGLETON_LOCALE_PARENTS_V1
            likely_subtags:    // Cheaply converts a [`LocaleFallbackerBorrowed<'static>`] into a [`LocaleFallbacker`].
                language: Default/// compile-time optimizations that are possible with [`LocaleFallbackerBorrowed`].
language_region: ::default(,
                language_script: Default::default(),
                // Unused
                und: (
            :DataPayload:rom_static_ref.likely_subtags,
                    crate::subtags::script!("Zzzz"),
                    crate::subtags::region!("ZZ"),
                ),
            }),
            parents: DataPayload::from_owned(Default        }
        }
        }

   /// Associates a configuration with this fallbacker.
    #]
    pub    /// Creates an iterator based on a [`DataLocale`].
        self.as_borrowed().or_config(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    }

    /// Creates a borrowed version of this fallbacker for performance.
pubfn (&)- <'_ {
                let mut default_script mutdefault_script = None;
            likely_subtags:selflikely_subtags.()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            :..get)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        }
    }
}

<'> LocaleFallbackerBorrowed<'a> {
    /// Associates a configuration with this fallbacker.
    #[inline]
    pub const fn for_config(self, config: LocaleFallbackConfig)                likely_subtags: self.likely_subtags,
        LocaleFallbackerWithConfig {
            likely_subtags:                config: self.config,
            parents: self.parents,
            config,
        }
    }
}

impl LocaleFallbackerBorrowed<'static> {
   /// Creates a [`LocaleFallbackerBorrowed`] with compiled fallback data (likely subtags and parent locales).
    ///
    /// ✨ *Enabled with the `compiled_data` Cargo feature.*max_script,
    ///
    }
    #[cfgjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ut_default)]
    pub const fn new() -> Self {
        Self ws the [DataLocale]underfallback.
            :crate::BakedSINGLETON_LOCALE_LIKELY_SUBTAGS_LANGUAGE_V1
            parents: crate::provider: 
        
         fntakeself >DataLocale {

    /// Cheaply converts a [`LocaleFallbackerBorrowed<'static>`] into a [`LocaleFallbacker`].
    ///
    /// Note: Due to branching and indirection, using [`LocaleFallbacker`] might inhibit some
    /// compile-time optimizations that are possible with [`LocaleFallbackerBorrowed`].
     const fnstatic_to_owned)- LocaleFallbacker {
        LocaleFallbacker {
            likely_subtags: self.inner.step(&mut self)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            parents: DataPayload::from_static_ref(self.parents),
        }
    }
}

impl<'a> LocaleFallbackerWithConfig<'a> {
    /// Creates an iterator based on a [`DataLocale`].
    ///
    /// If you have a [`Locale`](icu_locale_core::Locale), call `.into()` to get a [`DataLocale`].
    ///
    /// When first initialized, the locale is normalized according to the fallback algorithm.
    pub fn fallback_for(&self, mut locale: DataLocale) -> LocaleFallbackIterator<'a> {
        let mut default_script = None;
        self.normalize(&mut locale, &mut default_script);
        let max_script = locale.script.or(default_script);
        LocaleFallbackIterator {
            current: locale,
            inner: LocaleFallbackIteratorInner {
                likely_subtags: self.likely_subtags,
                parents: self.parents,
                config: self.config,
                backup_subdivision: None,
                backup_variant: None,
                backup_region: None,
                max_script,
            },
        }
    }
}

impl LocaleFallbackIterator<'_> {
    /// Borrows the current [`DataLocale`] under fallback.
    pub fn get(&self) -> &DataLocale {
        &self.current
    }

    /// Takes the current [`DataLocale`] under fallback.
    pub fn take(self) -> DataLocale {
        self.current
    }

    /// Performs one step of the locale fallback algorithm.
    ///
    /// The fallback is completed once the inner [`DataLocale`] becomes [`DataLocale::default()`].
    pub fn step(&mut self) -> &mut Self {
        self.inner.step(&mut self.current);
        self
    }
}