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"))]
136unsafe impl NSCoding for NSNumberFormatter {}
137
138#[cfg(all(feature = "NSFormatter", feature = "NSObject"))]
139unsafe impl NSCopying for NSNumberFormatter {}
140
141#[cfg(all(feature = "NSFormatter", feature = "NSObject"))]
142unsafe impl CopyingHelper for NSNumberFormatter {
143 type Result = Self;
144}
145
146#[cfg(feature = "NSFormatter")]
147unsafe impl NSObjectProtocol for NSNumberFormatter {}
148
149#[cfg(feature = "NSFormatter")]
150impl NSNumberFormatter {
151 extern_methods!(
152 #[unsafe(method(formattingContext))]
153 #[unsafe(method_family = none)]
154 pub unsafe fn formattingContext(&self) -> NSFormattingContext;
155
156 #[unsafe(method(setFormattingContext:))]
158 #[unsafe(method_family = none)]
159 pub unsafe fn setFormattingContext(&self, formatting_context: NSFormattingContext);
160
161 #[cfg(all(feature = "NSError", feature = "NSRange", feature = "NSString"))]
162 #[unsafe(method(getObjectValue:forString:range:error:_))]
163 #[unsafe(method_family = none)]
164 pub unsafe fn getObjectValue_forString_range_error(
165 &self,
166 obj: Option<&mut Option<Retained<AnyObject>>>,
167 string: &NSString,
168 rangep: *mut NSRange,
169 ) -> Result<(), Retained<NSError>>;
170
171 #[cfg(all(feature = "NSString", feature = "NSValue"))]
172 #[unsafe(method(stringFromNumber:))]
173 #[unsafe(method_family = none)]
174 pub unsafe fn stringFromNumber(&self, number: &NSNumber) -> Option<Retained<NSString>>;
175
176 #[cfg(all(feature = "NSString", feature = "NSValue"))]
177 #[unsafe(method(numberFromString:))]
178 #[unsafe(method_family = none)]
179 pub unsafe fn numberFromString(&self, string: &NSString) -> Option<Retained<NSNumber>>;
180
181 #[cfg(all(feature = "NSString", feature = "NSValue"))]
182 #[unsafe(method(localizedStringFromNumber:numberStyle:))]
183 #[unsafe(method_family = none)]
184 pub unsafe fn localizedStringFromNumber_numberStyle(
185 num: &NSNumber,
186 nstyle: NSNumberFormatterStyle,
187 ) -> Retained<NSString>;
188
189 #[unsafe(method(defaultFormatterBehavior))]
190 #[unsafe(method_family = none)]
191 pub unsafe fn defaultFormatterBehavior() -> NSNumberFormatterBehavior;
192
193 #[unsafe(method(setDefaultFormatterBehavior:))]
194 #[unsafe(method_family = none)]
195 pub unsafe fn setDefaultFormatterBehavior(behavior: NSNumberFormatterBehavior);
196
197 #[unsafe(method(minimumGroupingDigits))]
198 #[unsafe(method_family = none)]
199 pub unsafe fn minimumGroupingDigits(&self) -> NSInteger;
200
201 #[unsafe(method(setMinimumGroupingDigits:))]
203 #[unsafe(method_family = none)]
204 pub unsafe fn setMinimumGroupingDigits(&self, minimum_grouping_digits: NSInteger);
205
206 #[unsafe(method(numberStyle))]
207 #[unsafe(method_family = none)]
208 pub unsafe fn numberStyle(&self) -> NSNumberFormatterStyle;
209
210 #[unsafe(method(setNumberStyle:))]
212 #[unsafe(method_family = none)]
213 pub unsafe fn setNumberStyle(&self, number_style: NSNumberFormatterStyle);
214
215 #[cfg(feature = "NSLocale")]
216 #[unsafe(method(locale))]
217 #[unsafe(method_family = none)]
218 pub unsafe fn locale(&self) -> Retained<NSLocale>;
219
220 #[cfg(feature = "NSLocale")]
221 #[unsafe(method(setLocale:))]
223 #[unsafe(method_family = none)]
224 pub unsafe fn setLocale(&self, locale: Option<&NSLocale>);
225
226 #[unsafe(method(generatesDecimalNumbers))]
227 #[unsafe(method_family = none)]
228 pub unsafe fn generatesDecimalNumbers(&self) -> bool;
229
230 #[unsafe(method(setGeneratesDecimalNumbers:))]
232 #[unsafe(method_family = none)]
233 pub unsafe fn setGeneratesDecimalNumbers(&self, generates_decimal_numbers: bool);
234
235 #[unsafe(method(formatterBehavior))]
236 #[unsafe(method_family = none)]
237 pub unsafe fn formatterBehavior(&self) -> NSNumberFormatterBehavior;
238
239 #[unsafe(method(setFormatterBehavior:))]
241 #[unsafe(method_family = none)]
242 pub unsafe fn setFormatterBehavior(&self, formatter_behavior: NSNumberFormatterBehavior);
243
244 #[cfg(feature = "NSString")]
245 #[unsafe(method(negativeFormat))]
246 #[unsafe(method_family = none)]
247 pub unsafe fn negativeFormat(&self) -> Retained<NSString>;
248
249 #[cfg(feature = "NSString")]
250 #[unsafe(method(setNegativeFormat:))]
252 #[unsafe(method_family = none)]
253 pub unsafe fn setNegativeFormat(&self, negative_format: Option<&NSString>);
254
255 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
256 #[unsafe(method(textAttributesForNegativeValues))]
257 #[unsafe(method_family = none)]
258 pub unsafe fn textAttributesForNegativeValues(
259 &self,
260 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
261
262 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
263 #[unsafe(method(setTextAttributesForNegativeValues:))]
265 #[unsafe(method_family = none)]
266 pub unsafe fn setTextAttributesForNegativeValues(
267 &self,
268 text_attributes_for_negative_values: Option<&NSDictionary<NSString, AnyObject>>,
269 );
270
271 #[cfg(feature = "NSString")]
272 #[unsafe(method(positiveFormat))]
273 #[unsafe(method_family = none)]
274 pub unsafe fn positiveFormat(&self) -> Retained<NSString>;
275
276 #[cfg(feature = "NSString")]
277 #[unsafe(method(setPositiveFormat:))]
279 #[unsafe(method_family = none)]
280 pub unsafe fn setPositiveFormat(&self, positive_format: Option<&NSString>);
281
282 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
283 #[unsafe(method(textAttributesForPositiveValues))]
284 #[unsafe(method_family = none)]
285 pub unsafe fn textAttributesForPositiveValues(
286 &self,
287 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
288
289 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
290 #[unsafe(method(setTextAttributesForPositiveValues:))]
292 #[unsafe(method_family = none)]
293 pub unsafe fn setTextAttributesForPositiveValues(
294 &self,
295 text_attributes_for_positive_values: Option<&NSDictionary<NSString, AnyObject>>,
296 );
297
298 #[unsafe(method(allowsFloats))]
299 #[unsafe(method_family = none)]
300 pub unsafe fn allowsFloats(&self) -> bool;
301
302 #[unsafe(method(setAllowsFloats:))]
304 #[unsafe(method_family = none)]
305 pub unsafe fn setAllowsFloats(&self, allows_floats: bool);
306
307 #[cfg(feature = "NSString")]
308 #[unsafe(method(decimalSeparator))]
309 #[unsafe(method_family = none)]
310 pub unsafe fn decimalSeparator(&self) -> Retained<NSString>;
311
312 #[cfg(feature = "NSString")]
313 #[unsafe(method(setDecimalSeparator:))]
315 #[unsafe(method_family = none)]
316 pub unsafe fn setDecimalSeparator(&self, decimal_separator: Option<&NSString>);
317
318 #[unsafe(method(alwaysShowsDecimalSeparator))]
319 #[unsafe(method_family = none)]
320 pub unsafe fn alwaysShowsDecimalSeparator(&self) -> bool;
321
322 #[unsafe(method(setAlwaysShowsDecimalSeparator:))]
324 #[unsafe(method_family = none)]
325 pub unsafe fn setAlwaysShowsDecimalSeparator(&self, always_shows_decimal_separator: bool);
326
327 #[cfg(feature = "NSString")]
328 #[unsafe(method(currencyDecimalSeparator))]
329 #[unsafe(method_family = none)]
330 pub unsafe fn currencyDecimalSeparator(&self) -> Retained<NSString>;
331
332 #[cfg(feature = "NSString")]
333 #[unsafe(method(setCurrencyDecimalSeparator:))]
335 #[unsafe(method_family = none)]
336 pub unsafe fn setCurrencyDecimalSeparator(
337 &self,
338 currency_decimal_separator: Option<&NSString>,
339 );
340
341 #[unsafe(method(usesGroupingSeparator))]
342 #[unsafe(method_family = none)]
343 pub unsafe fn usesGroupingSeparator(&self) -> bool;
344
345 #[unsafe(method(setUsesGroupingSeparator:))]
347 #[unsafe(method_family = none)]
348 pub unsafe fn setUsesGroupingSeparator(&self, uses_grouping_separator: bool);
349
350 #[cfg(feature = "NSString")]
351 #[unsafe(method(groupingSeparator))]
352 #[unsafe(method_family = none)]
353 pub unsafe fn groupingSeparator(&self) -> Retained<NSString>;
354
355 #[cfg(feature = "NSString")]
356 #[unsafe(method(setGroupingSeparator:))]
358 #[unsafe(method_family = none)]
359 pub unsafe fn setGroupingSeparator(&self, grouping_separator: Option<&NSString>);
360
361 #[cfg(feature = "NSString")]
362 #[unsafe(method(zeroSymbol))]
363 #[unsafe(method_family = none)]
364 pub unsafe fn zeroSymbol(&self) -> Option<Retained<NSString>>;
365
366 #[cfg(feature = "NSString")]
367 #[unsafe(method(setZeroSymbol:))]
369 #[unsafe(method_family = none)]
370 pub unsafe fn setZeroSymbol(&self, zero_symbol: Option<&NSString>);
371
372 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
373 #[unsafe(method(textAttributesForZero))]
374 #[unsafe(method_family = none)]
375 pub unsafe fn textAttributesForZero(
376 &self,
377 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
378
379 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
380 #[unsafe(method(setTextAttributesForZero:))]
382 #[unsafe(method_family = none)]
383 pub unsafe fn setTextAttributesForZero(
384 &self,
385 text_attributes_for_zero: Option<&NSDictionary<NSString, AnyObject>>,
386 );
387
388 #[cfg(feature = "NSString")]
389 #[unsafe(method(nilSymbol))]
390 #[unsafe(method_family = none)]
391 pub unsafe fn nilSymbol(&self) -> Retained<NSString>;
392
393 #[cfg(feature = "NSString")]
394 #[unsafe(method(setNilSymbol:))]
396 #[unsafe(method_family = none)]
397 pub unsafe fn setNilSymbol(&self, nil_symbol: &NSString);
398
399 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
400 #[unsafe(method(textAttributesForNil))]
401 #[unsafe(method_family = none)]
402 pub unsafe fn textAttributesForNil(
403 &self,
404 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
405
406 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
407 #[unsafe(method(setTextAttributesForNil:))]
409 #[unsafe(method_family = none)]
410 pub unsafe fn setTextAttributesForNil(
411 &self,
412 text_attributes_for_nil: Option<&NSDictionary<NSString, AnyObject>>,
413 );
414
415 #[cfg(feature = "NSString")]
416 #[unsafe(method(notANumberSymbol))]
417 #[unsafe(method_family = none)]
418 pub unsafe fn notANumberSymbol(&self) -> Retained<NSString>;
419
420 #[cfg(feature = "NSString")]
421 #[unsafe(method(setNotANumberSymbol:))]
423 #[unsafe(method_family = none)]
424 pub unsafe fn setNotANumberSymbol(&self, not_a_number_symbol: Option<&NSString>);
425
426 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
427 #[unsafe(method(textAttributesForNotANumber))]
428 #[unsafe(method_family = none)]
429 pub unsafe fn textAttributesForNotANumber(
430 &self,
431 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
432
433 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
434 #[unsafe(method(setTextAttributesForNotANumber:))]
436 #[unsafe(method_family = none)]
437 pub unsafe fn setTextAttributesForNotANumber(
438 &self,
439 text_attributes_for_not_a_number: Option<&NSDictionary<NSString, AnyObject>>,
440 );
441
442 #[cfg(feature = "NSString")]
443 #[unsafe(method(positiveInfinitySymbol))]
444 #[unsafe(method_family = none)]
445 pub unsafe fn positiveInfinitySymbol(&self) -> Retained<NSString>;
446
447 #[cfg(feature = "NSString")]
448 #[unsafe(method(setPositiveInfinitySymbol:))]
450 #[unsafe(method_family = none)]
451 pub unsafe fn setPositiveInfinitySymbol(&self, positive_infinity_symbol: &NSString);
452
453 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
454 #[unsafe(method(textAttributesForPositiveInfinity))]
455 #[unsafe(method_family = none)]
456 pub unsafe fn textAttributesForPositiveInfinity(
457 &self,
458 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
459
460 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
461 #[unsafe(method(setTextAttributesForPositiveInfinity:))]
463 #[unsafe(method_family = none)]
464 pub unsafe fn setTextAttributesForPositiveInfinity(
465 &self,
466 text_attributes_for_positive_infinity: Option<&NSDictionary<NSString, AnyObject>>,
467 );
468
469 #[cfg(feature = "NSString")]
470 #[unsafe(method(negativeInfinitySymbol))]
471 #[unsafe(method_family = none)]
472 pub unsafe fn negativeInfinitySymbol(&self) -> Retained<NSString>;
473
474 #[cfg(feature = "NSString")]
475 #[unsafe(method(setNegativeInfinitySymbol:))]
477 #[unsafe(method_family = none)]
478 pub unsafe fn setNegativeInfinitySymbol(&self, negative_infinity_symbol: &NSString);
479
480 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
481 #[unsafe(method(textAttributesForNegativeInfinity))]
482 #[unsafe(method_family = none)]
483 pub unsafe fn textAttributesForNegativeInfinity(
484 &self,
485 ) -> Option<Retained<NSDictionary<NSString, AnyObject>>>;
486
487 #[cfg(all(feature = "NSDictionary", feature = "NSString"))]
488 #[unsafe(method(setTextAttributesForNegativeInfinity:))]
490 #[unsafe(method_family = none)]
491 pub unsafe fn setTextAttributesForNegativeInfinity(
492 &self,
493 text_attributes_for_negative_infinity: Option<&NSDictionary<NSString, AnyObject>>,
494 );
495
496 #[cfg(feature = "NSString")]
497 #[unsafe(method(positivePrefix))]
498 #[unsafe(method_family = none)]
499 pub unsafe fn positivePrefix(&self) -> Retained<NSString>;
500
501 #[cfg(feature = "NSString")]
502 #[unsafe(method(setPositivePrefix:))]
504 #[unsafe(method_family = none)]
505 pub unsafe fn setPositivePrefix(&self, positive_prefix: Option<&NSString>);
506
507 #[cfg(feature = "NSString")]
508 #[unsafe(method(positiveSuffix))]
509 #[unsafe(method_family = none)]
510 pub unsafe fn positiveSuffix(&self) -> Retained<NSString>;
511
512 #[cfg(feature = "NSString")]
513 #[unsafe(method(setPositiveSuffix:))]
515 #[unsafe(method_family = none)]
516 pub unsafe fn setPositiveSuffix(&self, positive_suffix: Option<&NSString>);
517
518 #[cfg(feature = "NSString")]
519 #[unsafe(method(negativePrefix))]
520 #[unsafe(method_family = none)]
521 pub unsafe fn negativePrefix(&self) -> Retained<NSString>;
522
523 #[cfg(feature = "NSString")]
524 #[unsafe(method(setNegativePrefix:))]
526 #[unsafe(method_family = none)]
527 pub unsafe fn setNegativePrefix(&self, negative_prefix: Option<&NSString>);
528
529 #[cfg(feature = "NSString")]
530 #[unsafe(method(negativeSuffix))]
531 #[unsafe(method_family = none)]
532 pub unsafe fn negativeSuffix(&self) -> Retained<NSString>;
533
534 #[cfg(feature = "NSString")]
535 #[unsafe(method(setNegativeSuffix:))]
537 #[unsafe(method_family = none)]
538 pub unsafe fn setNegativeSuffix(&self, negative_suffix: Option<&NSString>);
539
540 #[cfg(feature = "NSString")]
541 #[unsafe(method(currencyCode))]
542 #[unsafe(method_family = none)]
543 pub unsafe fn currencyCode(&self) -> Retained<NSString>;
544
545 #[cfg(feature = "NSString")]
546 #[unsafe(method(setCurrencyCode:))]
548 #[unsafe(method_family = none)]
549 pub unsafe fn setCurrencyCode(&self, currency_code: Option<&NSString>);
550
551 #[cfg(feature = "NSString")]
552 #[unsafe(method(currencySymbol))]
553 #[unsafe(method_family = none)]
554 pub unsafe fn currencySymbol(&self) -> Retained<NSString>;
555
556 #[cfg(feature = "NSString")]
557 #[unsafe(method(setCurrencySymbol:))]
559 #[unsafe(method_family = none)]
560 pub unsafe fn setCurrencySymbol(&self, currency_symbol: Option<&NSString>);
561
562 #[cfg(feature = "NSString")]
563 #[unsafe(method(internationalCurrencySymbol))]
564 #[unsafe(method_family = none)]
565 pub unsafe fn internationalCurrencySymbol(&self) -> Retained<NSString>;
566
567 #[cfg(feature = "NSString")]
568 #[unsafe(method(setInternationalCurrencySymbol:))]
570 #[unsafe(method_family = none)]
571 pub unsafe fn setInternationalCurrencySymbol(
572 &self,
573 international_currency_symbol: Option<&NSString>,
574 );
575
576 #[cfg(feature = "NSString")]
577 #[unsafe(method(percentSymbol))]
578 #[unsafe(method_family = none)]
579 pub unsafe fn percentSymbol(&self) -> Retained<NSString>;
580
581 #[cfg(feature = "NSString")]
582 #[unsafe(method(setPercentSymbol:))]
584 #[unsafe(method_family = none)]
585 pub unsafe fn setPercentSymbol(&self, percent_symbol: Option<&NSString>);
586
587 #[cfg(feature = "NSString")]
588 #[unsafe(method(perMillSymbol))]
589 #[unsafe(method_family = none)]
590 pub unsafe fn perMillSymbol(&self) -> Retained<NSString>;
591
592 #[cfg(feature = "NSString")]
593 #[unsafe(method(setPerMillSymbol:))]
595 #[unsafe(method_family = none)]
596 pub unsafe fn setPerMillSymbol(&self, per_mill_symbol: Option<&NSString>);
597
598 #[cfg(feature = "NSString")]
599 #[unsafe(method(minusSign))]
600 #[unsafe(method_family = none)]
601 pub unsafe fn minusSign(&self) -> Retained<NSString>;
602
603 #[cfg(feature = "NSString")]
604 #[unsafe(method(setMinusSign:))]
606 #[unsafe(method_family = none)]
607 pub unsafe fn setMinusSign(&self, minus_sign: Option<&NSString>);
608
609 #[cfg(feature = "NSString")]
610 #[unsafe(method(plusSign))]
611 #[unsafe(method_family = none)]
612 pub unsafe fn plusSign(&self) -> Retained<NSString>;
613
614 #[cfg(feature = "NSString")]
615 #[unsafe(method(setPlusSign:))]
617 #[unsafe(method_family = none)]
618 pub unsafe fn setPlusSign(&self, plus_sign: Option<&NSString>);
619
620 #[cfg(feature = "NSString")]
621 #[unsafe(method(exponentSymbol))]
622 #[unsafe(method_family = none)]
623 pub unsafe fn exponentSymbol(&self) -> Retained<NSString>;
624
625 #[cfg(feature = "NSString")]
626 #[unsafe(method(setExponentSymbol:))]
628 #[unsafe(method_family = none)]
629 pub unsafe fn setExponentSymbol(&self, exponent_symbol: Option<&NSString>);
630
631 #[unsafe(method(groupingSize))]
632 #[unsafe(method_family = none)]
633 pub unsafe fn groupingSize(&self) -> NSUInteger;
634
635 #[unsafe(method(setGroupingSize:))]
637 #[unsafe(method_family = none)]
638 pub unsafe fn setGroupingSize(&self, grouping_size: NSUInteger);
639
640 #[unsafe(method(secondaryGroupingSize))]
641 #[unsafe(method_family = none)]
642 pub unsafe fn secondaryGroupingSize(&self) -> NSUInteger;
643
644 #[unsafe(method(setSecondaryGroupingSize:))]
646 #[unsafe(method_family = none)]
647 pub unsafe fn setSecondaryGroupingSize(&self, secondary_grouping_size: NSUInteger);
648
649 #[cfg(feature = "NSValue")]
650 #[unsafe(method(multiplier))]
651 #[unsafe(method_family = none)]
652 pub unsafe fn multiplier(&self) -> Option<Retained<NSNumber>>;
653
654 #[cfg(feature = "NSValue")]
655 #[unsafe(method(setMultiplier:))]
657 #[unsafe(method_family = none)]
658 pub unsafe fn setMultiplier(&self, multiplier: Option<&NSNumber>);
659
660 #[unsafe(method(formatWidth))]
661 #[unsafe(method_family = none)]
662 pub unsafe fn formatWidth(&self) -> NSUInteger;
663
664 #[unsafe(method(setFormatWidth:))]
666 #[unsafe(method_family = none)]
667 pub unsafe fn setFormatWidth(&self, format_width: NSUInteger);
668
669 #[cfg(feature = "NSString")]
670 #[unsafe(method(paddingCharacter))]
671 #[unsafe(method_family = none)]
672 pub unsafe fn paddingCharacter(&self) -> Retained<NSString>;
673
674 #[cfg(feature = "NSString")]
675 #[unsafe(method(setPaddingCharacter:))]
677 #[unsafe(method_family = none)]
678 pub unsafe fn setPaddingCharacter(&self, padding_character: Option<&NSString>);
679
680 #[unsafe(method(paddingPosition))]
681 #[unsafe(method_family = none)]
682 pub unsafe fn paddingPosition(&self) -> NSNumberFormatterPadPosition;
683
684 #[unsafe(method(setPaddingPosition:))]
686 #[unsafe(method_family = none)]
687 pub unsafe fn setPaddingPosition(&self, padding_position: NSNumberFormatterPadPosition);
688
689 #[unsafe(method(roundingMode))]
690 #[unsafe(method_family = none)]
691 pub unsafe fn roundingMode(&self) -> NSNumberFormatterRoundingMode;
692
693 #[unsafe(method(setRoundingMode:))]
695 #[unsafe(method_family = none)]
696 pub unsafe fn setRoundingMode(&self, rounding_mode: NSNumberFormatterRoundingMode);
697
698 #[cfg(feature = "NSValue")]
699 #[unsafe(method(roundingIncrement))]
700 #[unsafe(method_family = none)]
701 pub unsafe fn roundingIncrement(&self) -> Retained<NSNumber>;
702
703 #[cfg(feature = "NSValue")]
704 #[unsafe(method(setRoundingIncrement:))]
706 #[unsafe(method_family = none)]
707 pub unsafe fn setRoundingIncrement(&self, rounding_increment: Option<&NSNumber>);
708
709 #[unsafe(method(minimumIntegerDigits))]
710 #[unsafe(method_family = none)]
711 pub unsafe fn minimumIntegerDigits(&self) -> NSUInteger;
712
713 #[unsafe(method(setMinimumIntegerDigits:))]
715 #[unsafe(method_family = none)]
716 pub unsafe fn setMinimumIntegerDigits(&self, minimum_integer_digits: NSUInteger);
717
718 #[unsafe(method(maximumIntegerDigits))]
719 #[unsafe(method_family = none)]
720 pub unsafe fn maximumIntegerDigits(&self) -> NSUInteger;
721
722 #[unsafe(method(setMaximumIntegerDigits:))]
724 #[unsafe(method_family = none)]
725 pub unsafe fn setMaximumIntegerDigits(&self, maximum_integer_digits: NSUInteger);
726
727 #[unsafe(method(minimumFractionDigits))]
728 #[unsafe(method_family = none)]
729 pub unsafe fn minimumFractionDigits(&self) -> NSUInteger;
730
731 #[unsafe(method(setMinimumFractionDigits:))]
733 #[unsafe(method_family = none)]
734 pub unsafe fn setMinimumFractionDigits(&self, minimum_fraction_digits: NSUInteger);
735
736 #[unsafe(method(maximumFractionDigits))]
737 #[unsafe(method_family = none)]
738 pub unsafe fn maximumFractionDigits(&self) -> NSUInteger;
739
740 #[unsafe(method(setMaximumFractionDigits:))]
742 #[unsafe(method_family = none)]
743 pub unsafe fn setMaximumFractionDigits(&self, maximum_fraction_digits: NSUInteger);
744
745 #[cfg(feature = "NSValue")]
746 #[unsafe(method(minimum))]
747 #[unsafe(method_family = none)]
748 pub unsafe fn minimum(&self) -> Option<Retained<NSNumber>>;
749
750 #[cfg(feature = "NSValue")]
751 #[unsafe(method(setMinimum:))]
753 #[unsafe(method_family = none)]
754 pub unsafe fn setMinimum(&self, minimum: Option<&NSNumber>);
755
756 #[cfg(feature = "NSValue")]
757 #[unsafe(method(maximum))]
758 #[unsafe(method_family = none)]
759 pub unsafe fn maximum(&self) -> Option<Retained<NSNumber>>;
760
761 #[cfg(feature = "NSValue")]
762 #[unsafe(method(setMaximum:))]
764 #[unsafe(method_family = none)]
765 pub unsafe fn setMaximum(&self, maximum: Option<&NSNumber>);
766
767 #[cfg(feature = "NSString")]
768 #[unsafe(method(currencyGroupingSeparator))]
769 #[unsafe(method_family = none)]
770 pub unsafe fn currencyGroupingSeparator(&self) -> Retained<NSString>;
771
772 #[cfg(feature = "NSString")]
773 #[unsafe(method(setCurrencyGroupingSeparator:))]
775 #[unsafe(method_family = none)]
776 pub unsafe fn setCurrencyGroupingSeparator(
777 &self,
778 currency_grouping_separator: Option<&NSString>,
779 );
780
781 #[unsafe(method(isLenient))]
782 #[unsafe(method_family = none)]
783 pub unsafe fn isLenient(&self) -> bool;
784
785 #[unsafe(method(setLenient:))]
787 #[unsafe(method_family = none)]
788 pub unsafe fn setLenient(&self, lenient: bool);
789
790 #[unsafe(method(usesSignificantDigits))]
791 #[unsafe(method_family = none)]
792 pub unsafe fn usesSignificantDigits(&self) -> bool;
793
794 #[unsafe(method(setUsesSignificantDigits:))]
796 #[unsafe(method_family = none)]
797 pub unsafe fn setUsesSignificantDigits(&self, uses_significant_digits: bool);
798
799 #[unsafe(method(minimumSignificantDigits))]
800 #[unsafe(method_family = none)]
801 pub unsafe fn minimumSignificantDigits(&self) -> NSUInteger;
802
803 #[unsafe(method(setMinimumSignificantDigits:))]
805 #[unsafe(method_family = none)]
806 pub unsafe fn setMinimumSignificantDigits(&self, minimum_significant_digits: NSUInteger);
807
808 #[unsafe(method(maximumSignificantDigits))]
809 #[unsafe(method_family = none)]
810 pub unsafe fn maximumSignificantDigits(&self) -> NSUInteger;
811
812 #[unsafe(method(setMaximumSignificantDigits:))]
814 #[unsafe(method_family = none)]
815 pub unsafe fn setMaximumSignificantDigits(&self, maximum_significant_digits: NSUInteger);
816
817 #[unsafe(method(isPartialStringValidationEnabled))]
818 #[unsafe(method_family = none)]
819 pub unsafe fn isPartialStringValidationEnabled(&self) -> bool;
820
821 #[unsafe(method(setPartialStringValidationEnabled:))]
823 #[unsafe(method_family = none)]
824 pub unsafe fn setPartialStringValidationEnabled(
825 &self,
826 partial_string_validation_enabled: bool,
827 );
828 );
829}
830
831#[cfg(feature = "NSFormatter")]
833impl NSNumberFormatter {
834 extern_methods!(
835 #[unsafe(method(init))]
836 #[unsafe(method_family = init)]
837 pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
838
839 #[unsafe(method(new))]
840 #[unsafe(method_family = new)]
841 pub unsafe fn new() -> Retained<Self>;
842 );
843}
844
845#[cfg(feature = "NSFormatter")]
847impl NSNumberFormatter {
848 extern_methods!(
849 #[unsafe(method(hasThousandSeparators))]
850 #[unsafe(method_family = none)]
851 pub unsafe fn hasThousandSeparators(&self) -> bool;
852
853 #[unsafe(method(setHasThousandSeparators:))]
855 #[unsafe(method_family = none)]
856 pub unsafe fn setHasThousandSeparators(&self, has_thousand_separators: bool);
857
858 #[cfg(feature = "NSString")]
859 #[unsafe(method(thousandSeparator))]
860 #[unsafe(method_family = none)]
861 pub unsafe fn thousandSeparator(&self) -> Retained<NSString>;
862
863 #[cfg(feature = "NSString")]
864 #[unsafe(method(setThousandSeparator:))]
866 #[unsafe(method_family = none)]
867 pub unsafe fn setThousandSeparator(&self, thousand_separator: Option<&NSString>);
868
869 #[unsafe(method(localizesFormat))]
870 #[unsafe(method_family = none)]
871 pub unsafe fn localizesFormat(&self) -> bool;
872
873 #[unsafe(method(setLocalizesFormat:))]
875 #[unsafe(method_family = none)]
876 pub unsafe fn setLocalizesFormat(&self, localizes_format: bool);
877
878 #[cfg(feature = "NSString")]
879 #[unsafe(method(format))]
880 #[unsafe(method_family = none)]
881 pub unsafe fn format(&self) -> Retained<NSString>;
882
883 #[cfg(feature = "NSString")]
884 #[unsafe(method(setFormat:))]
886 #[unsafe(method_family = none)]
887 pub unsafe fn setFormat(&self, format: &NSString);
888
889 #[cfg(feature = "NSAttributedString")]
890 #[unsafe(method(attributedStringForZero))]
891 #[unsafe(method_family = none)]
892 pub unsafe fn attributedStringForZero(&self) -> Retained<NSAttributedString>;
893
894 #[cfg(feature = "NSAttributedString")]
895 #[unsafe(method(setAttributedStringForZero:))]
897 #[unsafe(method_family = none)]
898 pub unsafe fn setAttributedStringForZero(
899 &self,
900 attributed_string_for_zero: &NSAttributedString,
901 );
902
903 #[cfg(feature = "NSAttributedString")]
904 #[unsafe(method(attributedStringForNil))]
905 #[unsafe(method_family = none)]
906 pub unsafe fn attributedStringForNil(&self) -> Retained<NSAttributedString>;
907
908 #[cfg(feature = "NSAttributedString")]
909 #[unsafe(method(setAttributedStringForNil:))]
911 #[unsafe(method_family = none)]
912 pub unsafe fn setAttributedStringForNil(
913 &self,
914 attributed_string_for_nil: &NSAttributedString,
915 );
916
917 #[cfg(feature = "NSAttributedString")]
918 #[unsafe(method(attributedStringForNotANumber))]
919 #[unsafe(method_family = none)]
920 pub unsafe fn attributedStringForNotANumber(&self) -> Retained<NSAttributedString>;
921
922 #[cfg(feature = "NSAttributedString")]
923 #[unsafe(method(setAttributedStringForNotANumber:))]
925 #[unsafe(method_family = none)]
926 pub unsafe fn setAttributedStringForNotANumber(
927 &self,
928 attributed_string_for_not_a_number: &NSAttributedString,
929 );
930
931 #[cfg(feature = "NSDecimalNumber")]
932 #[unsafe(method(roundingBehavior))]
933 #[unsafe(method_family = none)]
934 pub unsafe fn roundingBehavior(&self) -> Retained<NSDecimalNumberHandler>;
935
936 #[cfg(feature = "NSDecimalNumber")]
937 #[unsafe(method(setRoundingBehavior:))]
939 #[unsafe(method_family = none)]
940 pub unsafe fn setRoundingBehavior(&self, rounding_behavior: &NSDecimalNumberHandler);
941 );
942}