intl/icu_capi/src/normalizer.rs

   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 #[diplomat::bridge]
   6 pub mod ffi {
   7     use crate::{errors::ffi::ICU4XError, provider::ffi::ICU4XDataProvider};
   8     use alloc::boxed::Box;
   9     use diplomat_runtime::DiplomatWriteable;
  10     use icu_normalizer::{ComposingNormalizer, DecomposingNormalizer};
  11
  12     #[diplomat::opaque]
  13     #[diplomat::rust_link(icu::normalizer::ComposingNormalizer, Struct)]
  14     pub struct ICU4XComposingNormalizer(pub ComposingNormalizer);
  15
  16     impl ICU4XComposingNormalizer {
  17         /// Construct a new ICU4XComposingNormalizer instance for NFC
  18         #[diplomat::rust_link(icu::normalizer::ComposingNormalizer::new_nfc, FnInStruct)]
  19         pub fn create_nfc(
  20             provider: &ICU4XDataProvider,
  21         ) -> Result<Box<ICU4XComposingNormalizer>, ICU4XError> {
  22             Ok(Box::new(ICU4XComposingNormalizer(call_constructor!(
  23                 ComposingNormalizer::new_nfc [r => Ok(r)],
  24                 ComposingNormalizer::try_new_nfc_with_any_provider,
  25                 ComposingNormalizer::try_new_nfc_with_buffer_provider,
  26                 provider,
  27             )?)))
  28         }
  29
  30         /// Construct a new ICU4XComposingNormalizer instance for NFKC
  31         #[diplomat::rust_link(icu::normalizer::ComposingNormalizer::new_nfkc, FnInStruct)]
  32         pub fn create_nfkc(
  33             provider: &ICU4XDataProvider,
  34         ) -> Result<Box<ICU4XComposingNormalizer>, ICU4XError> {
  35             Ok(Box::new(ICU4XComposingNormalizer(call_constructor!(
  36                 ComposingNormalizer::new_nfkc [r => Ok(r)],
  37                 ComposingNormalizer::try_new_nfkc_with_any_provider,
  38                 ComposingNormalizer::try_new_nfkc_with_buffer_provider,
  39                 provider,
  40             )?)))
  41         }
  42
  43         /// Normalize a (potentially ill-formed) UTF8 string
  44         ///
  45         /// Errors are mapped to REPLACEMENT CHARACTER
  46         #[diplomat::rust_link(icu::normalizer::ComposingNormalizer::normalize_utf8, FnInStruct)]
  47         #[diplomat::rust_link(icu::normalizer::ComposingNormalizer::normalize, FnInStruct, hidden)]
  48         #[diplomat::rust_link(
  49             icu::normalizer::ComposingNormalizer::normalize_to,
  50             FnInStruct,
  51             hidden
  52         )]
  53         #[diplomat::rust_link(
  54             icu::normalizer::ComposingNormalizer::normalize_utf8_to,
  55             FnInStruct,
  56             hidden
  57         )]
  58         pub fn normalize(&self, s: &str, write: &mut DiplomatWriteable) -> Result<(), ICU4XError> {
  59             let s = s.as_bytes(); // #2520
  60             self.0.normalize_utf8_to(s, write)?;
  61             Ok(())
  62         }
  63
  64         /// Check if a (potentially ill-formed) UTF8 string is normalized
  65         ///
  66         /// Errors are mapped to REPLACEMENT CHARACTER
  67         #[diplomat::rust_link(icu::normalizer::ComposingNormalizer::is_normalized_utf8, FnInStruct)]
  68         #[diplomat::rust_link(
  69             icu::normalizer::ComposingNormalizer::is_normalized,
  70             FnInStruct,
  71             hidden
  72         )]
  73         pub fn is_normalized(&self, s: &str) -> bool {
  74             let s = s.as_bytes(); // #2520
  75             self.0.is_normalized_utf8(s)
  76         }
  77     }
  78
  79     #[diplomat::opaque]
  80     #[diplomat::rust_link(icu::normalizer::DecomposingNormalizer, Struct)]
  81     pub struct ICU4XDecomposingNormalizer(pub DecomposingNormalizer);
  82
  83     impl ICU4XDecomposingNormalizer {
  84         /// Construct a new ICU4XDecomposingNormalizer instance for NFC
  85         #[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::new_nfd, FnInStruct)]
  86         pub fn create_nfd(
  87             provider: &ICU4XDataProvider,
  88         ) -> Result<Box<ICU4XDecomposingNormalizer>, ICU4XError> {
  89             Ok(Box::new(ICU4XDecomposingNormalizer(call_constructor!(
  90                 DecomposingNormalizer::new_nfd [r => Ok(r)],
  91                 DecomposingNormalizer::try_new_nfd_with_any_provider,
  92                 DecomposingNormalizer::try_new_nfd_with_buffer_provider,
  93                 provider,
  94             )?)))
  95         }
  96
  97         /// Construct a new ICU4XDecomposingNormalizer instance for NFKC
  98         #[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::new_nfkd, FnInStruct)]
  99         pub fn create_nfkd(
 100             provider: &ICU4XDataProvider,
 101         ) -> Result<Box<ICU4XDecomposingNormalizer>, ICU4XError> {
 102             Ok(Box::new(ICU4XDecomposingNormalizer(call_constructor!(
 103                 DecomposingNormalizer::new_nfkd [r => Ok(r)],
 104                 DecomposingNormalizer::try_new_nfkd_with_any_provider,
 105                 DecomposingNormalizer::try_new_nfkd_with_buffer_provider,
 106                 provider,
 107             )?)))
 108         }
 109
 110         /// Normalize a (potentially ill-formed) UTF8 string
 111         ///
 112         /// Errors are mapped to REPLACEMENT CHARACTER
 113         #[diplomat::rust_link(icu::normalizer::DecomposingNormalizer::normalize_utf8, FnInStruct)]
 114         #[diplomat::rust_link(
 115             icu::normalizer::DecomposingNormalizer::normalize,
 116             FnInStruct,
 117             hidden
 118         )]
 119         #[diplomat::rust_link(
 120             icu::normalizer::DecomposingNormalizer::normalize_to,
 121             FnInStruct,
 122             hidden
 123         )]
 124         #[diplomat::rust_link(
 125             icu::normalizer::DecomposingNormalizer::normalize_utf8_to,
 126             FnInStruct,
 127             hidden
 128         )]
 129         pub fn normalize(&self, s: &str, write: &mut DiplomatWriteable) -> Result<(), ICU4XError> {
 130             let s = s.as_bytes(); // #2520
 131             self.0.normalize_utf8_to(s, write)?;
 132             Ok(())
 133         }
 134
 135         /// Check if a (potentially ill-formed) UTF8 string is normalized
 136         ///
 137         /// Errors are mapped to REPLACEMENT CHARACTER
 138         #[diplomat::rust_link(
 139             icu::normalizer::DecomposingNormalizer::is_normalized_utf8,
 140             FnInStruct
 141         )]
 142         #[diplomat::rust_link(
 143             icu::normalizer::DecomposingNormalizer::is_normalized,
 144             FnInStruct,
 145             hidden
 146         )]
 147         pub fn is_normalized(&self, s: &str) -> bool {
 148             let s = s.as_bytes(); // #2520
 149             self.0.is_normalized_utf8(s)
 150         }
 151     }
 152 }