Source code
Revision control
Copy as Markdown
Other Tools
// 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
#[diplomat::bridge]
pub mod ffi {
use crate::{errors::ffi::ICU4XError, provider::ffi::ICU4XDataProvider};
use alloc::boxed::Box;
use icu_normalizer::{ComposingNormalizer, DecomposingNormalizer};
#[diplomat::opaque]
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer, Struct)]
pub struct ICU4XComposingNormalizer(pub ComposingNormalizer);
impl ICU4XComposingNormalizer {
/// Construct a new ICU4XComposingNormalizer instance for NFC
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer::new_nfc, FnInStruct)]
#[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfc")]
pub fn create_nfc(
provider: &ICU4XDataProvider,
) -> Result<Box<ICU4XComposingNormalizer>, ICU4XError> {
Ok(Box::new(ICU4XComposingNormalizer(call_constructor!(
ComposingNormalizer::new_nfc [r => Ok(r)],
ComposingNormalizer::try_new_nfc_with_any_provider,
ComposingNormalizer::try_new_nfc_with_buffer_provider,
provider,
)?)))
}
/// Construct a new ICU4XComposingNormalizer instance for NFKC
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer::new_nfkc, FnInStruct)]
#[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfkc")]
pub fn create_nfkc(
provider: &ICU4XDataProvider,
) -> Result<Box<ICU4XComposingNormalizer>, ICU4XError> {
Ok(Box::new(ICU4XComposingNormalizer(call_constructor!(
ComposingNormalizer::new_nfkc [r => Ok(r)],
ComposingNormalizer::try_new_nfkc_with_any_provider,
ComposingNormalizer::try_new_nfkc_with_buffer_provider,
provider,
)?)))
}
/// Normalize a string
///
/// Ill-formed input is treated as if errors had been replaced with REPLACEMENT CHARACTERs according
/// to the WHATWG Encoding Standard.
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer::normalize_utf8, FnInStruct)]
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer::normalize, FnInStruct, hidden)]
#[diplomat::rust_link(
icu::normalizer::ComposingNormalizer::normalize_to,
FnInStruct,
hidden
)]
#[diplomat::rust_link(
icu::normalizer::ComposingNormalizer::normalize_utf8_to,
FnInStruct,
hidden
)]
pub fn normalize(
&self,
s: &DiplomatStr,
write: &mut DiplomatWriteable,
) -> Result<(), ICU4XError> {
self.0.normalize_utf8_to(s, write)?;
Ok(())
}
/// Check if a string is normalized
///
/// Ill-formed input is treated as if errors had been replaced with REPLACEMENT CHARACTERs according
/// to the WHATWG Encoding Standard.
#[diplomat::rust_link(icu::normalizer::ComposingNormalizer::is_normalized_utf8, FnInStruct)]
#[diplomat::rust_link(
icu::normalizer::ComposingNormalizer::is_normalized,
FnInStruct,
hidden
)]
pub fn is_normalized(&self, s: &DiplomatStr) -> bool {
self.0.is_normalized_utf8(s)
}
}
#[diplomat::opaque]
#[diplomat::rust_link(icu::normalizer::DecomposingNormalizer, Struct)]
pub struct ICU4XDecomposingNormalizer(pub DecomposingNormalizer);
impl ICU4XDecomposingNormalizer {
/// Construct a new ICU4XDecomposingNormalizer instance for NFC
#[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::new_nfd, FnInStruct)]
#[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfd")]
pub fn create_nfd(
provider: &ICU4XDataProvider,
) -> Result<Box<ICU4XDecomposingNormalizer>, ICU4XError> {
Ok(Box::new(ICU4XDecomposingNormalizer(call_constructor!(
DecomposingNormalizer::new_nfd [r => Ok(r)],
DecomposingNormalizer::try_new_nfd_with_any_provider,
DecomposingNormalizer::try_new_nfd_with_buffer_provider,
provider,
)?)))
}
/// Construct a new ICU4XDecomposingNormalizer instance for NFKC
#[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::new_nfkd, FnInStruct)]
#[diplomat::attr(all(supports = constructors, supports = fallible_constructors, supports = named_constructors), named_constructor = "nfkd")]
pub fn create_nfkd(
provider: &ICU4XDataProvider,
) -> Result<Box<ICU4XDecomposingNormalizer>, ICU4XError> {
Ok(Box::new(ICU4XDecomposingNormalizer(call_constructor!(
DecomposingNormalizer::new_nfkd [r => Ok(r)],
DecomposingNormalizer::try_new_nfkd_with_any_provider,
DecomposingNormalizer::try_new_nfkd_with_buffer_provider,
provider,
)?)))
}
/// Normalize a string
///
/// Ill-formed input is treated as if errors had been replaced with REPLACEMENT CHARACTERs according
/// to the WHATWG Encoding Standard.
#[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::normalize_utf8, FnInStruct)]
#[diplomat::rust_link(
icu::normalizer::DecomposingNormalizer::normalize,
FnInStruct,
hidden
)]
#[diplomat::rust_link(
icu::normalizer::DecomposingNormalizer::normalize_to,
FnInStruct,
hidden
)]
#[diplomat::rust_link(
icu::normalizer::DecomposingNormalizer::normalize_utf8_to,
FnInStruct,
hidden
)]
pub fn normalize(
&self,
s: &DiplomatStr,
write: &mut DiplomatWriteable,
) -> Result<(), ICU4XError> {
self.0.normalize_utf8_to(s, write)?;
Ok(())
}
/// Check if a string is normalized
///
/// Ill-formed input is treated as if errors had been replaced with REPLACEMENT CHARACTERs according
/// to the WHATWG Encoding Standard.
#[diplomat::rust_link(
icu::normalizer::DecomposingNormalizer::is_normalized_utf8,
FnInStruct
)]
#[diplomat::rust_link(
icu::normalizer::DecomposingNormalizer::is_normalized,
FnInStruct,
hidden
)]
pub fn is_normalized(&self, s: &DiplomatStr) -> bool {
self.0.is_normalized_utf8(s)
}
}
}