/rust/registry/src/index.crates.io-6f17d22bba15001f/icu_capi-1.5.1/src/fallbacker.rs

Source (jump to first uncovered line)
// 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 ).

#[diplomat::bridge]
pub mod ffi {
    use alloc::boxed::Box;
    use icu_locid_transform::fallback::LocaleFallbackConfig;
    use icu_locid_transform::fallback::LocaleFallbackIterator;
    use icu_locid_transform::fallback::LocaleFallbackPriority;
    use icu_locid_transform::fallback::LocaleFallbackerWithConfig;
    use icu_locid_transform::LocaleFallbacker;

    use crate::{
        errors::ffi::ICU4XError, locale::ffi::ICU4XLocale, provider::ffi::ICU4XDataProvider,
    };

    /// An object that runs the ICU4X locale fallback algorithm.
    #[diplomat::opaque]
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker, Struct)]
    #[diplomat::rust_link(
        icu::locid_transform::fallback::LocaleFallbackerBorrowed,
        Struct,
        hidden
    )]
    pub struct ICU4XLocaleFallbacker(pub LocaleFallbacker);

    /// Priority mode for the ICU4X fallback algorithm.
    #[diplomat::enum_convert(LocaleFallbackPriority, needs_wildcard)]
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackPriority, Enum)]
    #[diplomat::rust_link(
        icu::locid_transform::fallback::LocaleFallbackPriority::const_default,
        FnInEnum,
        hidden
    )]
    pub enum ICU4XLocaleFallbackPriority {
        Language = 0,
        Region = 1,
        Collation = 2,
    }

    /// What additional data is required to load when performing fallback.
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackSupplement, Enum)]
    #[diplomat::rust_link(
        icu::locid_transform::fallback::LocaleFallbackSupplement::const_default,
        FnInEnum,
        hidden
    )]
    pub enum ICU4XLocaleFallbackSupplement {
        None = 0,
        Collation = 1,
    }

    /// Collection of configurations for the ICU4X fallback algorithm.
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackConfig, Struct)]
    #[diplomat::rust_link(
        icu::locid_transform::fallback::LocaleFallbackConfig::const_default,
        FnInStruct,
        hidden
    )]
    pub struct ICU4XLocaleFallbackConfig<'a> {
        /// Choice of priority mode.
        pub priority: ICU4XLocaleFallbackPriority,
        /// An empty string is considered `None`.
        pub extension_key: &'a DiplomatStr,
        /// Fallback supplement data key to customize fallback rules.
        pub fallback_supplement: ICU4XLocaleFallbackSupplement,
    }

    /// An object that runs the ICU4X locale fallback algorithm with specific configurations.
    #[diplomat::opaque]
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker, Struct)]
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackerWithConfig, Struct)]
    pub struct ICU4XLocaleFallbackerWithConfig<'a>(pub LocaleFallbackerWithConfig<'a>);

    /// An iterator over the locale under fallback.
    #[diplomat::opaque]
    #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackIterator, Struct)]
    pub struct ICU4XLocaleFallbackIterator<'a>(pub LocaleFallbackIterator<'a, 'a>);

    impl ICU4XLocaleFallbacker {
        /// Creates a new `ICU4XLocaleFallbacker` from a data provider.
        #[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker::new, FnInStruct)]
        #[diplomat::attr(all(supports = constructors, supports = fallible_constructors), constructor)]
        pub fn create(
            provider: &ICU4XDataProvider,
        ) -> Result<Box<ICU4XLocaleFallbacker>, ICU4XError> {
            Ok(Box::new(ICU4XLocaleFallbacker(call_constructor!(
                LocaleFallbacker::new [r => Ok(r.static_to_owned())],
                LocaleFallbacker::try_new_with_any_provider,
                LocaleFallbacker::try_new_with_buffer_provider,
                provider,
            )?)))
        }

        /// Creates a new `ICU4XLocaleFallbacker` without data for limited functionality.
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbacker::new_without_data,
            FnInStruct
        )]
        #[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "without_data")]
        pub fn create_without_data() -> Box<ICU4XLocaleFallbacker> {
            Box::new(ICU4XLocaleFallbacker(LocaleFallbacker::new_without_data()))
        }

        /// Associates this `ICU4XLocaleFallbacker` with configuration options.
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbacker::for_config,
            FnInStruct
        )]
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackerBorrowed::for_config,
            FnInStruct,
            hidden
        )]
        pub fn for_config<'a, 'temp>(
            &'a self,
            config: ICU4XLocaleFallbackConfig<'temp>,
        ) -> Result<Box<ICU4XLocaleFallbackerWithConfig<'a>>, ICU4XError> {
            Ok(Box::new(ICU4XLocaleFallbackerWithConfig(
                self.0.for_config(LocaleFallbackConfig::try_from(config)?),
            )))
        }
    }

    impl<'a> ICU4XLocaleFallbackerWithConfig<'a> {
        /// Creates an iterator from a locale with each step of fallback.
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbacker::fallback_for,
            FnInStruct
        )]
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackerBorrowed::fallback_for,
            FnInStruct,
            hidden
        )]
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackerWithConfig::fallback_for,
            FnInStruct,
            hidden
        )]
        pub fn fallback_for_locale<'b: 'a, 'temp>(
            &'b self,
            locale: &'temp ICU4XLocale,
        ) -> Box<ICU4XLocaleFallbackIterator<'a>> {
            Box::new(ICU4XLocaleFallbackIterator(
                self.0.fallback_for((&locale.0).into()),
            ))
        }
    }

    impl<'a> ICU4XLocaleFallbackIterator<'a> {
        /// Gets a snapshot of the current state of the locale.
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackIterator::get,
            FnInStruct
        )]
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackIterator::take,
            FnInStruct,
            hidden
        )]
        #[diplomat::attr(*, disable)]
        pub fn get(&self) -> Box<ICU4XLocale> {
            Box::new(ICU4XLocale(self.0.get().clone().into_locale()))
        }

        /// Performs one step of the fallback algorithm, mutating the locale.
        #[diplomat::rust_link(
            icu::locid_transform::fallback::LocaleFallbackIterator::step,
            FnInStruct
        )]
        #[diplomat::attr(*, disable)]
        pub fn step(&mut self) {
            self.0.step();
        }

        /// A combination of `get` and `step`. Returns the value that `get` would return
        /// and advances the iterator until hitting `und`.
        #[diplomat::attr(supports = iterators, iterator)]
        #[diplomat::skip_if_ast]
        pub fn next(&mut self) -> Option<Box<ICU4XLocale>> {
            let current = self.get();
            if current.0 == icu_locid::Locale::UND {
                None
            } else {
                self.step();
                Some(current)
            }
        }
    }
}

impl TryFrom<ffi::ICU4XLocaleFallbackConfig<'_>>
    for icu_locid_transform::fallback::LocaleFallbackConfig
{
    type Error = crate::errors::ffi::ICU4XError;
    fn try_from(other: ffi::ICU4XLocaleFallbackConfig) -> Result<Self, Self::Error> {
        let mut result = Self::default();
        result.priority = other.priority.into();
        result.extension_key = match other.extension_key {
            b"" => None,
            s => Some(icu_locid::extensions::unicode::Key::try_from_bytes(s)?),
        };
        result.fallback_supplement = match other.fallback_supplement {
            ffi::ICU4XLocaleFallbackSupplement::None => None,
            ffi::ICU4XLocaleFallbackSupplement::Collation => {
                Some(icu_locid_transform::fallback::LocaleFallbackSupplement::Collation)
            }
        };
        Ok(result)
    }
}

Coverage Report

Created: 2025-07-18 06:22

Line	Count	Source (jump to first uncovered line)
1		// This file is part of ICU4X. For terms of use, please see the file
2		// called LICENSE at the top level of the ICU4X source tree
3		// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	0	#[diplomat::bridge] Unexecuted instantiation: ICU4XLocaleFallbackConfig_destroy Unexecuted instantiation: ICU4XLocaleFallbackIterator_get Unexecuted instantiation: ICU4XLocaleFallbackIterator_step Unexecuted instantiation: ICU4XLocaleFallbackIterator_next Unexecuted instantiation: ICU4XLocaleFallbackIterator_destroy Unexecuted instantiation: ICU4XLocaleFallbackPriority_destroy Unexecuted instantiation: ICU4XLocaleFallbackSupplement_destroy Unexecuted instantiation: ICU4XLocaleFallbacker_create Unexecuted instantiation: ICU4XLocaleFallbacker_create_without_data Unexecuted instantiation: ICU4XLocaleFallbacker_for_config Unexecuted instantiation: ICU4XLocaleFallbacker_destroy Unexecuted instantiation: ICU4XLocaleFallbackerWithConfig_fallback_for_locale Unexecuted instantiation: ICU4XLocaleFallbackerWithConfig_destroy
6		pub mod ffi {
7		use alloc::boxed::Box;
8		use icu_locid_transform::fallback::LocaleFallbackConfig;
9		use icu_locid_transform::fallback::LocaleFallbackIterator;
10		use icu_locid_transform::fallback::LocaleFallbackPriority;
11		use icu_locid_transform::fallback::LocaleFallbackerWithConfig;
12		use icu_locid_transform::LocaleFallbacker;
13
14		use crate::{
15		errors::ffi::ICU4XError, locale::ffi::ICU4XLocale, provider::ffi::ICU4XDataProvider,
16		};
17
18		/// An object that runs the ICU4X locale fallback algorithm.
19		#[diplomat::opaque]
20		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker, Struct)]
21		#[diplomat::rust_link(
22		icu::locid_transform::fallback::LocaleFallbackerBorrowed,
23		Struct,
24		hidden
25		)]
26		pub struct ICU4XLocaleFallbacker(pub LocaleFallbacker);
27
28		/// Priority mode for the ICU4X fallback algorithm.
29	0	#[diplomat::enum_convert(LocaleFallbackPriority, needs_wildcard)] Unexecuted instantiation: <icu_provider::fallback::LocaleFallbackPriority as core::convert::From<icu_capi::fallbacker::ffi::ICU4XLocaleFallbackPriority>>::from Unexecuted instantiation: <icu_capi::fallbacker::ffi::ICU4XLocaleFallbackPriority as core::convert::From<icu_provider::fallback::LocaleFallbackPriority>>::from
30		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackPriority, Enum)]
31		#[diplomat::rust_link(
32		icu::locid_transform::fallback::LocaleFallbackPriority::const_default,
33		FnInEnum,
34		hidden
35		)]
36		pub enum ICU4XLocaleFallbackPriority {
37		Language = 0,
38		Region = 1,
39		Collation = 2,
40		}
41
42		/// What additional data is required to load when performing fallback.
43		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackSupplement, Enum)]
44		#[diplomat::rust_link(
45		icu::locid_transform::fallback::LocaleFallbackSupplement::const_default,
46		FnInEnum,
47		hidden
48		)]
49		pub enum ICU4XLocaleFallbackSupplement {
50		None = 0,
51		Collation = 1,
52		}
53
54		/// Collection of configurations for the ICU4X fallback algorithm.
55		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackConfig, Struct)]
56		#[diplomat::rust_link(
57		icu::locid_transform::fallback::LocaleFallbackConfig::const_default,
58		FnInStruct,
59		hidden
60		)]
61		pub struct ICU4XLocaleFallbackConfig<'a> {
62		/// Choice of priority mode.
63		pub priority: ICU4XLocaleFallbackPriority,
64		/// An empty string is considered `None`.
65		pub extension_key: &'a DiplomatStr,
66		/// Fallback supplement data key to customize fallback rules.
67		pub fallback_supplement: ICU4XLocaleFallbackSupplement,
68		}
69
70		/// An object that runs the ICU4X locale fallback algorithm with specific configurations.
71		#[diplomat::opaque]
72		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker, Struct)]
73		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackerWithConfig, Struct)]
74		pub struct ICU4XLocaleFallbackerWithConfig<'a>(pub LocaleFallbackerWithConfig<'a>);
75
76		/// An iterator over the locale under fallback.
77		#[diplomat::opaque]
78		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbackIterator, Struct)]
79		pub struct ICU4XLocaleFallbackIterator<'a>(pub LocaleFallbackIterator<'a, 'a>);
80
81		impl ICU4XLocaleFallbacker {
82		/// Creates a new `ICU4XLocaleFallbacker` from a data provider.
83		#[diplomat::rust_link(icu::locid_transform::fallback::LocaleFallbacker::new, FnInStruct)]
84		#[diplomat::attr(all(supports = constructors, supports = fallible_constructors), constructor)]
85	0	pub fn create(
86	0	provider: &ICU4XDataProvider,
87	0	) -> Result<Box<ICU4XLocaleFallbacker>, ICU4XError> {
88	0	Ok(Box::new(ICU4XLocaleFallbacker(call_constructor!(
89	0	LocaleFallbacker::new [r => Ok(r.static_to_owned())],
90		LocaleFallbacker::try_new_with_any_provider,
91		LocaleFallbacker::try_new_with_buffer_provider,
92		provider,
93	0	)?)))
94	0	}
95
96		/// Creates a new `ICU4XLocaleFallbacker` without data for limited functionality.
97		#[diplomat::rust_link(
98		icu::locid_transform::fallback::LocaleFallbacker::new_without_data,
99		FnInStruct
100		)]
101		#[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "without_data")]
102	0	pub fn create_without_data() -> Box<ICU4XLocaleFallbacker> {
103	0	Box::new(ICU4XLocaleFallbacker(LocaleFallbacker::new_without_data()))
104	0	}
105
106		/// Associates this `ICU4XLocaleFallbacker` with configuration options.
107		#[diplomat::rust_link(
108		icu::locid_transform::fallback::LocaleFallbacker::for_config,
109		FnInStruct
110		)]
111		#[diplomat::rust_link(
112		icu::locid_transform::fallback::LocaleFallbackerBorrowed::for_config,
113		FnInStruct,
114		hidden
115		)]
116	0	pub fn for_config<'a, 'temp>(
117	0	&'a self,
118	0	config: ICU4XLocaleFallbackConfig<'temp>,
119	0	) -> Result<Box<ICU4XLocaleFallbackerWithConfig<'a>>, ICU4XError> {
120	0	Ok(Box::new(ICU4XLocaleFallbackerWithConfig(
121	0	self.0.for_config(LocaleFallbackConfig::try_from(config)?),
122		)))
123	0	}
124		}
125
126		impl<'a> ICU4XLocaleFallbackerWithConfig<'a> {
127		/// Creates an iterator from a locale with each step of fallback.
128		#[diplomat::rust_link(
129		icu::locid_transform::fallback::LocaleFallbacker::fallback_for,
130		FnInStruct
131		)]
132		#[diplomat::rust_link(
133		icu::locid_transform::fallback::LocaleFallbackerBorrowed::fallback_for,
134		FnInStruct,
135		hidden
136		)]
137		#[diplomat::rust_link(
138		icu::locid_transform::fallback::LocaleFallbackerWithConfig::fallback_for,
139		FnInStruct,
140		hidden
141		)]
142	0	pub fn fallback_for_locale<'b: 'a, 'temp>(
143	0	&'b self,
144	0	locale: &'temp ICU4XLocale,
145	0	) -> Box<ICU4XLocaleFallbackIterator<'a>> {
146	0	Box::new(ICU4XLocaleFallbackIterator(
147	0	self.0.fallback_for((&locale.0).into()),
148	0	))
149	0	}
150		}
151
152		impl<'a> ICU4XLocaleFallbackIterator<'a> {
153		/// Gets a snapshot of the current state of the locale.
154		#[diplomat::rust_link(
155		icu::locid_transform::fallback::LocaleFallbackIterator::get,
156		FnInStruct
157		)]
158		#[diplomat::rust_link(
159		icu::locid_transform::fallback::LocaleFallbackIterator::take,
160		FnInStruct,
161		hidden
162		)]
163		#[diplomat::attr(*, disable)]
164	0	pub fn get(&self) -> Box<ICU4XLocale> {
165	0	Box::new(ICU4XLocale(self.0.get().clone().into_locale()))
166	0	}
167
168		/// Performs one step of the fallback algorithm, mutating the locale.
169		#[diplomat::rust_link(
170		icu::locid_transform::fallback::LocaleFallbackIterator::step,
171		FnInStruct
172		)]
173		#[diplomat::attr(*, disable)]
174	0	pub fn step(&mut self) {
175	0	self.0.step();
176	0	}
177
178		/// A combination of `get` and `step`. Returns the value that `get` would return
179		/// and advances the iterator until hitting `und`.
180		#[diplomat::attr(supports = iterators, iterator)]
181		#[diplomat::skip_if_ast]
182	0	pub fn next(&mut self) -> Option<Box<ICU4XLocale>> {
183	0	let current = self.get();
184	0	if current.0 == icu_locid::Locale::UND {
185	0	None
186		} else {
187	0	self.step();
188	0	Some(current)
189		}
190	0	}
191		}
192		}
193
194		impl TryFrom<ffi::ICU4XLocaleFallbackConfig<'_>>
195		for icu_locid_transform::fallback::LocaleFallbackConfig
196		{
197		type Error = crate::errors::ffi::ICU4XError;
198	0	fn try_from(other: ffi::ICU4XLocaleFallbackConfig) -> Result<Self, Self::Error> {
199	0	let mut result = Self::default();
200	0	result.priority = other.priority.into();
201	0	result.extension_key = match other.extension_key {
202	0	b"" => None,
203	0	s => Some(icu_locid::extensions::unicode::Key::try_from_bytes(s)?),
204		};
205	0	result.fallback_supplement = match other.fallback_supplement {
206	0	ffi::ICU4XLocaleFallbackSupplement::None => None,
207		ffi::ICU4XLocaleFallbackSupplement::Collation => {
208	0	Some(icu_locid_transform::fallback::LocaleFallbackSupplement::Collation)
209		}
210		};
211	0	Ok(result)
212	0	}
213		}