1use core::ffi::*;
4use core::ptr::NonNull;
5use objc2::__framework_prelude::*;
6
7use crate::*;
8
9#[repr(transparent)]
12#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
13pub struct NSNumberFormatterBehavior(pub NSUInteger);
14impl NSNumberFormatterBehavior {
15 #[doc(alias = "NSNumberFormatterBehaviorDefault")]
16 pub const BehaviorDefault: Self = Self(0);
17 #[doc(alias = "NSNumberFormatterBehavior10_0")]
18 pub const Behavior10_0: Self = Self(1000);
19 #[doc(alias = "NSNumberFormatterBehavior10_4")]
20 pub const Behavior10_4: Self = Self(1040);
21}
22
23unsafe impl Encode for NSNumberFormatterBehavior {
24 const ENCODING: Encoding = NSUInteger::ENCODING;
25}
26
27unsafe impl RefEncode for NSNumberFormatterBehavior {
28 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
29}
30
31#[repr(transparent)]
34#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
35pub struct NSNumberFormatterStyle(pub NSUInteger);
36impl NSNumberFormatterStyle {
37 #[doc(alias = "NSNumberFormatterNoStyle")]
38 pub const NoStyle: Self = Self(0);
39 #[doc(alias = "NSNumberFormatterDecimalStyle")]
40 pub const DecimalStyle: Self = Self(1);
41 #[doc(alias = "NSNumberFormatterCurrencyStyle")]
42 pub const CurrencyStyle: Self = Self(2);
43 #[doc(alias = "NSNumberFormatterPercentStyle")]
44 pub const PercentStyle: Self = Self(3);
45 #[doc(alias = "NSNumberFormatterScientificStyle")]
46 pub const ScientificStyle: Self = Self(4);
47 #[doc(alias = "NSNumberFormatterSpellOutStyle")]
48 pub const SpellOutStyle: Self = Self(5);
49 #[doc(alias = "NSNumberFormatterOrdinalStyle")]
50 pub const OrdinalStyle: Self = Self(6);
51 #[doc(alias = "NSNumberFormatterCurrencyISOCodeStyle")]
52 pub const CurrencyISOCodeStyle: Self = Self(8);
53 #[doc(alias = "NSNumberFormatterCurrencyPluralStyle")]
54 pub const CurrencyPluralStyle: Self = Self(9);
55 #[doc(alias = "NSNumberFormatterCurrencyAccountingStyle")]
56 pub const CurrencyAccountingStyle: Self = Self(10);
57}
58
59unsafe impl Encode for NSNumberFormatterStyle {
60 const ENCODING: Encoding = NSUInteger::ENCODING;
61}
62
63unsafe impl RefEncode for NSNumberFormatterStyle {
64 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
65}
66
67#[repr(transparent)]
70#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
71pub struct NSNumberFormatterPadPosition(pub NSUInteger);
72impl NSNumberFormatterPadPosition {
73 #[doc(alias = "NSNumberFormatterPadBeforePrefix")]
74 pub const BeforePrefix: Self = Self(0);
75 #[doc(alias = "NSNumberFormatterPadAfterPrefix")]
76 pub const AfterPrefix: Self = Self(1);
77 #[doc(alias = "NSNumberFormatterPadBeforeSuffix")]
78 pub const BeforeSuffix: Self = Self(2);
79 #[doc(alias = "NSNumberFormatterPadAfterSuffix")]
80 pub const AfterSuffix: Self = Self(3);
81}
82
83unsafe impl Encode for NSNumberFormatterPadPosition {
84 const ENCODING: Encoding = NSUInteger::ENCODING;
85}
86
87unsafe impl RefEncode for NSNumberFormatterPadPosition {
88 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
89}
90
91#[repr(transparent)]
94#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
95pub struct NSNumberFormatterRoundingMode(pub NSUInteger);
96impl NSNumberFormatterRoundingMode {
97 #[doc(alias = "NSNumberFormatterRoundCeiling")]
98 pub const RoundCeiling: Self = Self(0);
99 #[doc(alias = "NSNumberFormatterRoundFloor")]
100 pub const RoundFloor: Self = Self(1);
101 #[doc(alias = "NSNumberFormatterRoundDown")]
102 pub const RoundDown: Self = Self(2);
103 #[doc(alias = "NSNumberFormatterRoundUp")]
104 pub const RoundUp: Self = Self(3);
105 #[doc(alias = "NSNumberFormatterRoundHalfEven")]
106 pub const RoundHalfEven: Self = Self(4);
107 #[doc(alias = "NSNumberFormatterRoundHalfDown")]
108 pub const RoundHalfDown: Self = Self(5);
109 #[doc(alias = "NSNumberFormatterRoundHalfUp")]
110 pub const RoundHalfUp: Self = Self(6);
111}
112
113unsafe impl Encode for NSNumberFormatterRoundingMode {
114 const ENCODING: Encoding = NSUInteger::ENCODING;
115}
116
117unsafe impl RefEncode for NSNumberFormatterRoundingMode {
118 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
119}
120
121extern_class!(
122 #[unsafe(super(NSFormatter, NSObject))]
124 #[derive(Debug, PartialEq, Eq, Hash)]
125 #[cfg(feature = "NSFormatter")]
126 pub struct NSNumberFormatter;
127);
128
129#[cfg(feature = "NSFormatter")]
130unsafe impl Send for NSNumberFormatter {}
131
132#[cfg(feature = "NSFormatter")]
133unsafe impl Sync for NSNumberFormatter {}
134
135#[cfg(all(feature = "NSFormatter", feature = "NSObject"))]
136extern_conformance!(
137 unsafe impl NSCoding for NSNumberFormatter {}
138);
139
140#[cfg(all(feature = "NSFormatter", feature = "NSObject"))]
141extern_conformance!(
142 unsafe impl NSCopying for NSNumberFormatter {}
143);
144
145#[cfg(all(feature = "NSFormatter", feature = "NSObject"))]
146unsafe impl CopyingHelper for NSNumberFormatter {
147 type Result = Self;
148}
149
150#[cfg(feature = "NSFormatter")]
151extern_conformance!(
152 unsafe impl NSObjectProtocol for NSNumberFormatter {}
153);
154
155#[cfg(feature = "NSFormatter")]
156impl NSNumberFormatter {
157 extern_methods!(
158 #[unsafe(method(formattingContext))]
159 #[unsafe(method_family = none)]
160 pub unsafe fn formattingContext(&self) -> NSFormattingContext;
161
162 #[unsafe(method(setFormattingContext:))]
164 #[unsafe(method_family = none)]
165 pub unsafe fn setFormattingContext(&self, formatting_context: NSFormattingContext);
166
167 #[cfg(all(feature = "NSError", feature = "NSRange", feature = "NSString"))]
168 #[unsafe(method(getObjectValue:forString:range:error:_))]
169 #[unsafe(method_family = none)]
170 pub unsafe fn getObjectValue_forString_range_error(
171 &self,
172 obj: Option<&mut Option<Retained<AnyObject>>>,
173 string: &NSString,
174 rangep: *mut NSRange,
175 ) -> Result<(), Retained<NSError>>;
176
177 #[cfg(all(feature = "NSString", feature = "NSValue"))]
178 #[unsafe(method(stringFromNumber:))]
179 #[unsafe(method_family = none)]
180 pub unsafe fn stringFromNumber(&self, number: &NSNumber) -> Option<Retained<NSString>>;
181
182 #[cfg(all(feature = "NSString", feature = "NSValue"))]
183 #[unsafe(method(numberFromString:))]
184 #[unsafe(method_family = none)]
185 pub unsafe fn numberFromString(&self, string: &NSString) -> Option<Retained<NSNumber>>;
186
187 #[cfg(all(feature = "NSString", feature = "NSValue"))]
188 #[unsafe(method(localizedStringFromNumber:numberStyle:))]
189 #[unsafe(method_family = none)]
190 pub unsafe fn localizedStringFromNumber_numberStyle(
191 num: &NSNumber,
192 nstyle: NSNumberFormatterStyle,
193 ) -> Retained<NSString>;
194
195 #[unsafe(method(defaultFormatterBehavior))]
196 #[unsafe(method_family = none)]
197 pub unsafe fn defaultFormatterBehavior() -> NSNumberFormatterBehavior;
198
199 #[unsafe(method(setDefaultFormatterBehavior:))]
200 #[unsafe(method_family = none)]
201 pub unsafe fn setDefaultFormatterBehavior(behavior: NSNumberFormatterBehavior);
202
203 #[unsafe(method(minimumGroupingDigits))]
204 #[unsafe(method_family = none)]
205 pub unsafe fn minimumGroupingDigits(&self) -> NSInteger;
206
207 #[unsafe(method(setMinimumGroupingDigits:))]
209 #[unsafe(method_family = none)]
210 pub unsafe fn setMinimumGroupingDigits(&self, minimum_grouping_digits: NSInteger);
211
212 #[unsafe(method(numberStyle))]
213 #[unsafe(method_family = none)]
214 pub unsafe fn numberStyle(&self) -> NSNumberFormatterStyle;
215
216 #[unsafe(method(setNumberStyle:))]
218 #[unsafe(method_family = none)]
219 pub unsafe fn setNumberStyle(&self, number_style: NSNumberFormatterStyle);
220
221 #[cfg(feature = "NSLocale")]
222 #[unsafe(method(locale))]
223 #[unsafe(method_family = none)]
224 pub unsafe fn locale(&self) -> Retained<NSLocale>;
225
226 #[cfg(feature = "NSLocale")]
227 #[unsafe(method(setLocale:))]
229 #[unsafe(method_family = none)]
230 pub unsafe fn setLocale(&self, locale: Option<&NSLocale>);
231
232 #[unsafe(method(generatesDecimalNumbers))]
233 #[unsafe(method_family = none)]
234 pub unsafe fn generatesDecimalNumbers(&self) -> bool;
235
236 #[unsafe(method(setGeneratesDecimalNumbers:))]
238 #[unsafe(method_family = none)]
239 pub unsafe fn setGeneratesDecimalNumbers(&self, generates_decimal_numbers: bool);
240
241 #[unsafe(method(formatterBehavior))]
242 #[unsafe(method_family = none)]
243 pub unsafe fn formatterBehavior(&self) -> NSNumberFormatterBehavior;
244
245 #[unsafe(method(setFormatterBehavior:))]
247 #[unsafe(method_family = none)]
248 pub unsafe fn setFormatterBehavior(&self, formatter_behavior: NSNumberFormatterBehavior);
249
250 #[cfg(feature = "NSString")]
251 #[unsafe(method(negativeFormat))]
252 #[unsafe(method_family = none)]
253 pub unsafe fn negativeFormat(&self) -> Retained<NSString>;
254
255 #[cfg(feature = "NSString")]
256 #[unsafe(method(setNegativeFormat:))]
258 #[unsafe(method_family = none)]
259 pub unsafe fn setNegativeFormat(&self, negative_format: Option<&NSString>);
260
261 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
262 #[unsafe(method(textAttributesForNegativeValues))]
263 #[unsafe(method_family = none)]
264 pub unsafe fn textAttributesForNegativeValues(
265 &self,
266 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
267
268 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
269 #[unsafe(method(setTextAttributesForNegativeValues:))]
271 #[unsafe(method_family = none)]
272 pub unsafe fn setTextAttributesForNegativeValues(
273 &self,
274 text_attributes_for_negative_values: Option<&NSDictionary<NSString, AnyObject>>,
275 );
276
277 #[cfg(feature = "NSString")]
278 #[unsafe(method(positiveFormat))]
279 #[unsafe(method_family = none)]
280 pub unsafe fn positiveFormat(&self) -> Retained<NSString>;
281
282 #[cfg(feature = "NSString")]
283 #[unsafe(method(setPositiveFormat:))]
285 #[unsafe(method_family = none)]
286 pub unsafe fn setPositiveFormat(&self, positive_format: Option<&NSString>);
287
288 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
289 #[unsafe(method(textAttributesForPositiveValues))]
290 #[unsafe(method_family = none)]
291 pub unsafe fn textAttributesForPositiveValues(
292 &self,
293 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
294
295 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
296 #[unsafe(method(setTextAttributesForPositiveValues:))]
298 #[unsafe(method_family = none)]
299 pub unsafe fn setTextAttributesForPositiveValues(
300 &self,
301 text_attributes_for_positive_values: Option<&NSDictionary<NSString, AnyObject>>,
302 );
303
304 #[unsafe(method(allowsFloats))]
305 #[unsafe(method_family = none)]
306 pub unsafe fn allowsFloats(&self) -> bool;
307
308 #[unsafe(method(setAllowsFloats:))]
310 #[unsafe(method_family = none)]
311 pub unsafe fn setAllowsFloats(&self, allows_floats: bool);
312
313 #[cfg(feature = "NSString")]
314 #[unsafe(method(decimalSeparator))]
315 #[unsafe(method_family = none)]
316 pub unsafe fn decimalSeparator(&self) -> Retained<NSString>;
317
318 #[cfg(feature = "NSString")]
319 #[unsafe(method(setDecimalSeparator:))]
321 #[unsafe(method_family = none)]
322 pub unsafe fn setDecimalSeparator(&self, decimal_separator: Option<&NSString>);
323
324 #[unsafe(method(alwaysShowsDecimalSeparator))]
325 #[unsafe(method_family = none)]
326 pub unsafe fn alwaysShowsDecimalSeparator(&self) -> bool;
327
328 #[unsafe(method(setAlwaysShowsDecimalSeparator:))]
330 #[unsafe(method_family = none)]
331 pub unsafe fn setAlwaysShowsDecimalSeparator(&self, always_shows_decimal_separator: bool);
332
333 #[cfg(feature = "NSString")]
334 #[unsafe(method(currencyDecimalSeparator))]
335 #[unsafe(method_family = none)]
336 pub unsafe fn currencyDecimalSeparator(&self) -> Retained<NSString>;
337
338 #[cfg(feature = "NSString")]
339 #[unsafe(method(setCurrencyDecimalSeparator:))]
341 #[unsafe(method_family = none)]
342 pub unsafe fn setCurrencyDecimalSeparator(
343 &self,
344 currency_decimal_separator: Option<&NSString>,
345 );
346
347 #[unsafe(method(usesGroupingSeparator))]
348 #[unsafe(method_family = none)]
349 pub unsafe fn usesGroupingSeparator(&self) -> bool;
350
351 #[unsafe(method(setUsesGroupingSeparator:))]
353 #[unsafe(method_family = none)]
354 pub unsafe fn setUsesGroupingSeparator(&self, uses_grouping_separator: bool);
355
356 #[cfg(feature = "NSString")]
357 #[unsafe(method(groupingSeparator))]
358 #[unsafe(method_family = none)]
359 pub unsafe fn groupingSeparator(&self) -> Retained<NSString>;
360
361 #[cfg(feature = "NSString")]
362 #[unsafe(method(setGroupingSeparator:))]
364 #[unsafe(method_family = none)]
365 pub unsafe fn setGroupingSeparator(&self, grouping_separator: Option<&NSString>);
366
367 #[cfg(feature = "NSString")]
368 #[unsafe(method(zeroSymbol))]
369 #[unsafe(method_family = none)]
370 pub unsafe fn zeroSymbol(&self) -> Option<Retained<NSString>>;
371
372 #[cfg(feature = "NSString")]
373 #[unsafe(method(setZeroSymbol:))]
375 #[unsafe(method_family = none)]
376 pub unsafe fn setZeroSymbol(&self, zero_symbol: Option<&NSString>);
377
378 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
379 #[unsafe(method(textAttributesForZero))]
380 #[unsafe(method_family = none)]
381 pub unsafe fn textAttributesForZero(
382 &self,
383 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
384
385 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
386 #[unsafe(method(setTextAttributesForZero:))]
388 #[unsafe(method_family = none)]
389 pub unsafe fn setTextAttributesForZero(
390 &self,
391 text_attributes_for_zero: Option<&NSDictionary<NSString, AnyObject>>,
392 );
393
394 #[cfg(feature = "NSString")]
395 #[unsafe(method(nilSymbol))]
396 #[unsafe(method_family = none)]
397 pub unsafe fn nilSymbol(&self) -> Retained<NSString>;
398
399 #[cfg(feature = "NSString")]
400 #[unsafe(method(setNilSymbol:))]
402 #[unsafe(method_family = none)]
403 pub unsafe fn setNilSymbol(&self, nil_symbol: &NSString);
404
405 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
406 #[unsafe(method(textAttributesForNil))]
407 #[unsafe(method_family = none)]
408 pub unsafe fn textAttributesForNil(
409 &self,
410 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
411
412 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
413 #[unsafe(method(setTextAttributesForNil:))]
415 #[unsafe(method_family = none)]
416 pub unsafe fn setTextAttributesForNil(
417 &self,
418 text_attributes_for_nil: Option<&NSDictionary<NSString, AnyObject>>,
419 );
420
421 #[cfg(feature = "NSString")]
422 #[unsafe(method(notANumberSymbol))]
423 #[unsafe(method_family = none)]
424 pub unsafe fn notANumberSymbol(&self) -> Retained<NSString>;
425
426 #[cfg(feature = "NSString")]
427 #[unsafe(method(setNotANumberSymbol:))]
429 #[unsafe(method_family = none)]
430 pub unsafe fn setNotANumberSymbol(&self, not_a_number_symbol: Option<&NSString>);
431
432 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
433 #[unsafe(method(textAttributesForNotANumber))]
434 #[unsafe(method_family = none)]
435 pub unsafe fn textAttributesForNotANumber(
436 &self,
437 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
438
439 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
440 #[unsafe(method(setTextAttributesForNotANumber:))]
442 #[unsafe(method_family = none)]
443 pub unsafe fn setTextAttributesForNotANumber(
444 &self,
445 text_attributes_for_not_a_number: Option<&NSDictionary<NSString, AnyObject>>,
446 );
447
448 #[cfg(feature = "NSString")]
449 #[unsafe(method(positiveInfinitySymbol))]
450 #[unsafe(method_family = none)]
451 pub unsafe fn positiveInfinitySymbol(&self) -> Retained<NSString>;
452
453 #[cfg(feature = "NSString")]
454 #[unsafe(method(setPositiveInfinitySymbol:))]
456 #[unsafe(method_family = none)]
457 pub unsafe fn setPositiveInfinitySymbol(&self, positive_infinity_symbol: &NSString);
458
459 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
460 #[unsafe(method(textAttributesForPositiveInfinity))]
461 #[unsafe(method_family = none)]
462 pub unsafe fn textAttributesForPositiveInfinity(
463 &self,
464 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
465
466 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
467 #[unsafe(method(setTextAttributesForPositiveInfinity:))]
469 #[unsafe(method_family = none)]
470 pub unsafe fn setTextAttributesForPositiveInfinity(
471 &self,
472 text_attributes_for_positive_infinity: Option<&NSDictionary<NSString, AnyObject>>,
473 );
474
475 #[cfg(feature = "NSString")]
476 #[unsafe(method(negativeInfinitySymbol))]
477 #[unsafe(method_family = none)]
478 pub unsafe fn negativeInfinitySymbol(&self) -> Retained<NSString>;
479
480 #[cfg(feature = "NSString")]
481 #[unsafe(method(setNegativeInfinitySymbol:))]
483 #[unsafe(method_family = none)]
484 pub unsafe fn setNegativeInfinitySymbol(&self, negative_infinity_symbol: &NSString);
485
486 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
487 #[unsafe(method(textAttributesForNegativeInfinity))]
488 #[unsafe(method_family = none)]
489 pub unsafe fn textAttributesForNegativeInfinity(
490 &self,
491 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
492
493 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
494 #[unsafe(method(setTextAttributesForNegativeInfinity:))]
496 #[unsafe(method_family = none)]
497 pub unsafe fn setTextAttributesForNegativeInfinity(
498 &self,
499 text_attributes_for_negative_infinity: Option<&NSDictionary<NSString, AnyObject>>,
500 );
501
502 #[cfg(feature = "NSString")]
503 #[unsafe(method(positivePrefix))]
504 #[unsafe(method_family = none)]
505 pub unsafe fn positivePrefix(&self) -> Retained<NSString>;
506
507 #[cfg(feature = "NSString")]
508 #[unsafe(method(setPositivePrefix:))]
510 #[unsafe(method_family = none)]
511 pub unsafe fn setPositivePrefix(&self, positive_prefix: Option<&NSString>);
512
513 #[cfg(feature = "NSString")]
514 #[unsafe(method(positiveSuffix))]
515 #[unsafe(method_family = none)]
516 pub unsafe fn positiveSuffix(&self) -> Retained<NSString>;
517
518 #[cfg(feature = "NSString")]
519 #[unsafe(method(setPositiveSuffix:))]
521 #[unsafe(method_family = none)]
522 pub unsafe fn setPositiveSuffix(&self, positive_suffix: Option<&NSString>);
523
524 #[cfg(feature = "NSString")]
525 #[unsafe(method(negativePrefix))]
526 #[unsafe(method_family = none)]
527 pub unsafe fn negativePrefix(&self) -> Retained<NSString>;
528
529 #[cfg(feature = "NSString")]
530 #[unsafe(method(setNegativePrefix:))]
532 #[unsafe(method_family = none)]
533 pub unsafe fn setNegativePrefix(&self, negative_prefix: Option<&NSString>);
534
535 #[cfg(feature = "NSString")]
536 #[unsafe(method(negativeSuffix))]
537 #[unsafe(method_family = none)]
538 pub unsafe fn negativeSuffix(&self) -> Retained<NSString>;
539
540 #[cfg(feature = "NSString")]
541 #[unsafe(method(setNegativeSuffix:))]
543 #[unsafe(method_family = none)]
544 pub unsafe fn setNegativeSuffix(&self, negative_suffix: Option<&NSString>);
545
546 #[cfg(feature = "NSString")]
547 #[unsafe(method(currencyCode))]
548 #[unsafe(method_family = none)]
549 pub unsafe fn currencyCode(&self) -> Retained<NSString>;
550
551 #[cfg(feature = "NSString")]
552 #[unsafe(method(setCurrencyCode:))]
554 #[unsafe(method_family = none)]
555 pub unsafe fn setCurrencyCode(&self, currency_code: Option<&NSString>);
556
557 #[cfg(feature = "NSString")]
558 #[unsafe(method(currencySymbol))]
559 #[unsafe(method_family = none)]
560 pub unsafe fn currencySymbol(&self) -> Retained<NSString>;
561
562 #[cfg(feature = "NSString")]
563 #[unsafe(method(setCurrencySymbol:))]
565 #[unsafe(method_family = none)]
566 pub unsafe fn setCurrencySymbol(&self, currency_symbol: Option<&NSString>);
567
568 #[cfg(feature = "NSString")]
569 #[unsafe(method(internationalCurrencySymbol))]
570 #[unsafe(method_family = none)]
571 pub unsafe fn internationalCurrencySymbol(&self) -> Retained<NSString>;
572
573 #[cfg(feature = "NSString")]
574 #[unsafe(method(setInternationalCurrencySymbol:))]
576 #[unsafe(method_family = none)]
577 pub unsafe fn setInternationalCurrencySymbol(
578 &self,
579 international_currency_symbol: Option<&NSString>,
580 );
581
582 #[cfg(feature = "NSString")]
583 #[unsafe(method(percentSymbol))]
584 #[unsafe(method_family = none)]
585 pub unsafe fn percentSymbol(&self) -> Retained<NSString>;
586
587 #[cfg(feature = "NSString")]
588 #[unsafe(method(setPercentSymbol:))]
590 #[unsafe(method_family = none)]
591 pub unsafe fn setPercentSymbol(&self, percent_symbol: Option<&NSString>);
592
593 #[cfg(feature = "NSString")]
594 #[unsafe(method(perMillSymbol))]
595 #[unsafe(method_family = none)]
596 pub unsafe fn perMillSymbol(&self) -> Retained<NSString>;
597
598 #[cfg(feature = "NSString")]
599 #[unsafe(method(setPerMillSymbol:))]
601 #[unsafe(method_family = none)]
602 pub unsafe fn setPerMillSymbol(&self, per_mill_symbol: Option<&NSString>);
603
604 #[cfg(feature = "NSString")]
605 #[unsafe(method(minusSign))]
606 #[unsafe(method_family = none)]
607 pub unsafe fn minusSign(&self) -> Retained<NSString>;
608
609 #[cfg(feature = "NSString")]
610 #[unsafe(method(setMinusSign:))]
612 #[unsafe(method_family = none)]
613 pub unsafe fn setMinusSign(&self, minus_sign: Option<&NSString>);
614
615 #[cfg(feature = "NSString")]
616 #[unsafe(method(plusSign))]
617 #[unsafe(method_family = none)]
618 pub unsafe fn plusSign(&self) -> Retained<NSString>;
619
620 #[cfg(feature = "NSString")]
621 #[unsafe(method(setPlusSign:))]
623 #[unsafe(method_family = none)]
624 pub unsafe fn setPlusSign(&self, plus_sign: Option<&NSString>);
625
626 #[cfg(feature = "NSString")]
627 #[unsafe(method(exponentSymbol))]
628 #[unsafe(method_family = none)]
629 pub unsafe fn exponentSymbol(&self) -> Retained<NSString>;
630
631 #[cfg(feature = "NSString")]
632 #[unsafe(method(setExponentSymbol:))]
634 #[unsafe(method_family = none)]
635 pub unsafe fn setExponentSymbol(&self, exponent_symbol: Option<&NSString>);
636
637 #[unsafe(method(groupingSize))]
638 #[unsafe(method_family = none)]
639 pub unsafe fn groupingSize(&self) -> NSUInteger;
640
641 #[unsafe(method(setGroupingSize:))]
643 #[unsafe(method_family = none)]
644 pub unsafe fn setGroupingSize(&self, grouping_size: NSUInteger);
645
646 #[unsafe(method(secondaryGroupingSize))]
647 #[unsafe(method_family = none)]
648 pub unsafe fn secondaryGroupingSize(&self) -> NSUInteger;
649
650 #[unsafe(method(setSecondaryGroupingSize:))]
652 #[unsafe(method_family = none)]
653 pub unsafe fn setSecondaryGroupingSize(&self, secondary_grouping_size: NSUInteger);
654
655 #[cfg(feature = "NSValue")]
656 #[unsafe(method(multiplier))]
657 #[unsafe(method_family = none)]
658 pub unsafe fn multiplier(&self) -> Option<Retained<NSNumber>>;
659
660 #[cfg(feature = "NSValue")]
661 #[unsafe(method(setMultiplier:))]
663 #[unsafe(method_family = none)]
664 pub unsafe fn setMultiplier(&self, multiplier: Option<&NSNumber>);
665
666 #[unsafe(method(formatWidth))]
667 #[unsafe(method_family = none)]
668 pub unsafe fn formatWidth(&self) -> NSUInteger;
669
670 #[unsafe(method(setFormatWidth:))]
672 #[unsafe(method_family = none)]
673 pub unsafe fn setFormatWidth(&self, format_width: NSUInteger);
674
675 #[cfg(feature = "NSString")]
676 #[unsafe(method(paddingCharacter))]
677 #[unsafe(method_family = none)]
678 pub unsafe fn paddingCharacter(&self) -> Retained<NSString>;
679
680 #[cfg(feature = "NSString")]
681 #[unsafe(method(setPaddingCharacter:))]
683 #[unsafe(method_family = none)]
684 pub unsafe fn setPaddingCharacter(&self, padding_character: Option<&NSString>);
685
686 #[unsafe(method(paddingPosition))]
687 #[unsafe(method_family = none)]
688 pub unsafe fn paddingPosition(&self) -> NSNumberFormatterPadPosition;
689
690 #[unsafe(method(setPaddingPosition:))]
692 #[unsafe(method_family = none)]
693 pub unsafe fn setPaddingPosition(&self, padding_position: NSNumberFormatterPadPosition);
694
695 #[unsafe(method(roundingMode))]
696 #[unsafe(method_family = none)]
697 pub unsafe fn roundingMode(&self) -> NSNumberFormatterRoundingMode;
698
699 #[unsafe(method(setRoundingMode:))]
701 #[unsafe(method_family = none)]
702 pub unsafe fn setRoundingMode(&self, rounding_mode: NSNumberFormatterRoundingMode);
703
704 #[cfg(feature = "NSValue")]
705 #[unsafe(method(roundingIncrement))]
706 #[unsafe(method_family = none)]
707 pub unsafe fn roundingIncrement(&self) -> Retained<NSNumber>;
708
709 #[cfg(feature = "NSValue")]
710 #[unsafe(method(setRoundingIncrement:))]
712 #[unsafe(method_family = none)]
713 pub unsafe fn setRoundingIncrement(&self, rounding_increment: Option<&NSNumber>);
714
715 #[unsafe(method(minimumIntegerDigits))]
716 #[unsafe(method_family = none)]
717 pub unsafe fn minimumIntegerDigits(&self) -> NSUInteger;
718
719 #[unsafe(method(setMinimumIntegerDigits:))]
721 #[unsafe(method_family = none)]
722 pub unsafe fn setMinimumIntegerDigits(&self, minimum_integer_digits: NSUInteger);
723
724 #[unsafe(method(maximumIntegerDigits))]
725 #[unsafe(method_family = none)]
726 pub unsafe fn maximumIntegerDigits(&self) -> NSUInteger;
727
728 #[unsafe(method(setMaximumIntegerDigits:))]
730 #[unsafe(method_family = none)]
731 pub unsafe fn setMaximumIntegerDigits(&self, maximum_integer_digits: NSUInteger);
732
733 #[unsafe(method(minimumFractionDigits))]
734 #[unsafe(method_family = none)]
735 pub unsafe fn minimumFractionDigits(&self) -> NSUInteger;
736
737 #[unsafe(method(setMinimumFractionDigits:))]
739 #[unsafe(method_family = none)]
740 pub unsafe fn setMinimumFractionDigits(&self, minimum_fraction_digits: NSUInteger);
741
742 #[unsafe(method(maximumFractionDigits))]
743 #[unsafe(method_family = none)]
744 pub unsafe fn maximumFractionDigits(&self) -> NSUInteger;
745
746 #[unsafe(method(setMaximumFractionDigits:))]
748 #[unsafe(method_family = none)]
749 pub unsafe fn setMaximumFractionDigits(&self, maximum_fraction_digits: NSUInteger);
750
751 #[cfg(feature = "NSValue")]
752 #[unsafe(method(minimum))]
753 #[unsafe(method_family = none)]
754 pub unsafe fn minimum(&self) -> Option<Retained<NSNumber>>;
755
756 #[cfg(feature = "NSValue")]
757 #[unsafe(method(setMinimum:))]
759 #[unsafe(method_family = none)]
760 pub unsafe fn setMinimum(&self, minimum: Option<&NSNumber>);
761
762 #[cfg(feature = "NSValue")]
763 #[unsafe(method(maximum))]
764 #[unsafe(method_family = none)]
765 pub unsafe fn maximum(&self) -> Option<Retained<NSNumber>>;
766
767 #[cfg(feature = "NSValue")]
768 #[unsafe(method(setMaximum:))]
770 #[unsafe(method_family = none)]
771 pub unsafe fn setMaximum(&self, maximum: Option<&NSNumber>);
772
773 #[cfg(feature = "NSString")]
774 #[unsafe(method(currencyGroupingSeparator))]
775 #[unsafe(method_family = none)]
776 pub unsafe fn currencyGroupingSeparator(&self) -> Retained<NSString>;
777
778 #[cfg(feature = "NSString")]
779 #[unsafe(method(setCurrencyGroupingSeparator:))]
781 #[unsafe(method_family = none)]
782 pub unsafe fn setCurrencyGroupingSeparator(
783 &self,
784 currency_grouping_separator: Option<&NSString>,
785 );
786
787 #[unsafe(method(isLenient))]
788 #[unsafe(method_family = none)]
789 pub unsafe fn isLenient(&self) -> bool;
790
791 #[unsafe(method(setLenient:))]
793 #[unsafe(method_family = none)]
794 pub unsafe fn setLenient(&self, lenient: bool);
795
796 #[unsafe(method(usesSignificantDigits))]
797 #[unsafe(method_family = none)]
798 pub unsafe fn usesSignificantDigits(&self) -> bool;
799
800 #[unsafe(method(setUsesSignificantDigits:))]
802 #[unsafe(method_family = none)]
803 pub unsafe fn setUsesSignificantDigits(&self, uses_significant_digits: bool);
804
805 #[unsafe(method(minimumSignificantDigits))]
806 #[unsafe(method_family = none)]
807 pub unsafe fn minimumSignificantDigits(&self) -> NSUInteger;
808
809 #[unsafe(method(setMinimumSignificantDigits:))]
811 #[unsafe(method_family = none)]
812 pub unsafe fn setMinimumSignificantDigits(&self, minimum_significant_digits: NSUInteger);
813
814 #[unsafe(method(maximumSignificantDigits))]
815 #[unsafe(method_family = none)]
816 pub unsafe fn maximumSignificantDigits(&self) -> NSUInteger;
817
818 #[unsafe(method(setMaximumSignificantDigits:))]
820 #[unsafe(method_family = none)]
821 pub unsafe fn setMaximumSignificantDigits(&self, maximum_significant_digits: NSUInteger);
822
823 #[unsafe(method(isPartialStringValidationEnabled))]
824 #[unsafe(method_family = none)]
825 pub unsafe fn isPartialStringValidationEnabled(&self) -> bool;
826
827 #[unsafe(method(setPartialStringValidationEnabled:))]
829 #[unsafe(method_family = none)]
830 pub unsafe fn setPartialStringValidationEnabled(
831 &self,
832 partial_string_validation_enabled: bool,
833 );
834 );
835}
836
837#[cfg(feature = "NSFormatter")]
839impl NSNumberFormatter {
840 extern_methods!(
841 #[unsafe(method(init))]
842 #[unsafe(method_family = init)]
843 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
844
845 #[unsafe(method(new))]
846 #[unsafe(method_family = new)]
847 pub unsafe fn new() -> Retained<Self>;
848 );
849}
850
851#[cfg(feature = "NSFormatter")]
853impl NSNumberFormatter {
854 extern_methods!(
855 #[unsafe(method(hasThousandSeparators))]
856 #[unsafe(method_family = none)]
857 pub unsafe fn hasThousandSeparators(&self) -> bool;
858
859 #[unsafe(method(setHasThousandSeparators:))]
861 #[unsafe(method_family = none)]
862 pub unsafe fn setHasThousandSeparators(&self, has_thousand_separators: bool);
863
864 #[cfg(feature = "NSString")]
865 #[unsafe(method(thousandSeparator))]
866 #[unsafe(method_family = none)]
867 pub unsafe fn thousandSeparator(&self) -> Retained<NSString>;
868
869 #[cfg(feature = "NSString")]
870 #[unsafe(method(setThousandSeparator:))]
872 #[unsafe(method_family = none)]
873 pub unsafe fn setThousandSeparator(&self, thousand_separator: Option<&NSString>);
874
875 #[unsafe(method(localizesFormat))]
876 #[unsafe(method_family = none)]
877 pub unsafe fn localizesFormat(&self) -> bool;
878
879 #[unsafe(method(setLocalizesFormat:))]
881 #[unsafe(method_family = none)]
882 pub unsafe fn setLocalizesFormat(&self, localizes_format: bool);
883
884 #[cfg(feature = "NSString")]
885 #[unsafe(method(format))]
886 #[unsafe(method_family = none)]
887 pub unsafe fn format(&self) -> Retained<NSString>;
888
889 #[cfg(feature = "NSString")]
890 #[unsafe(method(setFormat:))]
892 #[unsafe(method_family = none)]
893 pub unsafe fn setFormat(&self, format: &NSString);
894
895 #[cfg(feature = "NSAttributedString")]
896 #[unsafe(method(attributedStringForZero))]
897 #[unsafe(method_family = none)]
898 pub unsafe fn attributedStringForZero(&self) -> Retained<NSAttributedString>;
899
900 #[cfg(feature = "NSAttributedString")]
901 #[unsafe(method(setAttributedStringForZero:))]
903 #[unsafe(method_family = none)]
904 pub unsafe fn setAttributedStringForZero(
905 &self,
906 attributed_string_for_zero: &NSAttributedString,
907 );
908
909 #[cfg(feature = "NSAttributedString")]
910 #[unsafe(method(attributedStringForNil))]
911 #[unsafe(method_family = none)]
912 pub unsafe fn attributedStringForNil(&self) -> Retained<NSAttributedString>;
913
914 #[cfg(feature = "NSAttributedString")]
915 #[unsafe(method(setAttributedStringForNil:))]
917 #[unsafe(method_family = none)]
918 pub unsafe fn setAttributedStringForNil(
919 &self,
920 attributed_string_for_nil: &NSAttributedString,
921 );
922
923 #[cfg(feature = "NSAttributedString")]
924 #[unsafe(method(attributedStringForNotANumber))]
925 #[unsafe(method_family = none)]
926 pub unsafe fn attributedStringForNotANumber(&self) -> Retained<NSAttributedString>;
927
928 #[cfg(feature = "NSAttributedString")]
929 #[unsafe(method(setAttributedStringForNotANumber:))]
931 #[unsafe(method_family = none)]
932 pub unsafe fn setAttributedStringForNotANumber(
933 &self,
934 attributed_string_for_not_a_number: &NSAttributedString,
935 );
936
937 #[cfg(feature = "NSDecimalNumber")]
938 #[unsafe(method(roundingBehavior))]
939 #[unsafe(method_family = none)]
940 pub unsafe fn roundingBehavior(&self) -> Retained<NSDecimalNumberHandler>;
941
942 #[cfg(feature = "NSDecimalNumber")]
943 #[unsafe(method(setRoundingBehavior:))]
945 #[unsafe(method_family = none)]
946 pub unsafe fn setRoundingBehavior(&self, rounding_behavior: &NSDecimalNumberHandler);
947 );
948}