1#[rustfmt::skip]
8#[diplomat::bridge]
9#[diplomat::abi_rename = "icu4x_{0}_mv1"]
10#[diplomat::attr(auto, namespace = "icu4x")]
11pub mod ffi {
12 use alloc::boxed::Box;
13 use icu_calendar::Gregorian;
14 use writeable::TryWriteable;
15
16 #[allow(unused_imports)]
17 use crate::{
18 date_formatter::ffi::{DateFormatter, DateFormatterGregorian},
19 date_time_formatter::ffi::{DateTimeFormatter, DateTimeFormatterGregorian},
20 date::ffi::IsoDate,
21 datetime_helpers,
22 datetime_helpers::map_or_default,
23 datetime_options::ffi::{DateTimeAlignment, DateTimeLength, TimePrecision},
24 errors::ffi::DateTimeFormatterLoadError,
25 errors::ffi::DateTimeWriteError,
26 locale_core::ffi::Locale,
27 time_formatter::ffi::TimeFormatter,
28 time::ffi::Time,
29 timezone::ffi::TimeZoneInfo,
30 };
31
32 #[cfg(feature = "buffer_provider")]
33 use crate::provider::ffi::DataProvider;
34
35 #[diplomat::opaque]
36 #[diplomat::rust_link(icu::datetime::DateTimeFormatter, Typedef)]
37 pub struct ZonedDateTimeFormatter(
38 pub icu_datetime::DateTimeFormatter<
39 icu_datetime::fieldsets::enums::ZonedDateAndTimeFieldSet
40 >,
41 );
42
43 impl ZonedDateTimeFormatter {
44 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_long")]
45 #[cfg(feature = "compiled_data")]
46 pub fn create_specific_long(
47 locale: &Locale,
48 formatter: &DateTimeFormatter,
49 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
50 let zone = icu_datetime::fieldsets::zone::SpecificLong;
51 datetime_helpers::datetime_formatter_with_zone(
52 &formatter.0,
53 locale,
54 zone,
55 |names| {
56 names
57 .as_mut()
58 .include_time_zone_specific_long_names_with_fallback(
59 )?;
60 Ok(())
61 },
62 |names, field_set| names.try_into_formatter(
63 field_set
64 ),
65 )
66 }
67
68 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_long_with_provider")]
69 #[cfg(feature = "buffer_provider")]
70 pub fn create_specific_long_with_provider(
71 provider: &DataProvider,
72 locale: &Locale,
73 formatter: &DateTimeFormatter,
74 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
75 let provider = provider.get()?;
76 let zone = icu_datetime::fieldsets::zone::SpecificLong;
77 datetime_helpers::datetime_formatter_with_zone(
78 &formatter.0,
79 locale,
80 zone,
81 |names| {
82 use icu_provider::buf::AsDeserializingBufferProvider;
83 let provider = provider.as_deserializing();
84 names
85 .as_mut()
86 .load_time_zone_specific_long_names_with_fallback(
87 &provider
88 )?;
89 Ok(())
90 },
91 |names, field_set| names.try_into_formatter_with_buffer_provider(
92 &provider,
93 field_set
94 ),
95 )
96 }
97
98 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_short")]
99 #[cfg(feature = "compiled_data")]
100 pub fn create_specific_short(
101 locale: &Locale,
102 formatter: &DateTimeFormatter,
103 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
104 let zone = icu_datetime::fieldsets::zone::SpecificShort;
105 datetime_helpers::datetime_formatter_with_zone(
106 &formatter.0,
107 locale,
108 zone,
109 |names| {
110 names
111 .as_mut()
112 .include_time_zone_specific_short_names_with_fallback(
113 )?;
114 Ok(())
115 },
116 |names, field_set| names.try_into_formatter(
117 field_set
118 ),
119 )
120 }
121
122 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_short_with_provider")]
123 #[cfg(feature = "buffer_provider")]
124 pub fn create_specific_short_with_provider(
125 provider: &DataProvider,
126 locale: &Locale,
127 formatter: &DateTimeFormatter,
128 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
129 let provider = provider.get()?;
130 let zone = icu_datetime::fieldsets::zone::SpecificShort;
131 datetime_helpers::datetime_formatter_with_zone(
132 &formatter.0,
133 locale,
134 zone,
135 |names| {
136 use icu_provider::buf::AsDeserializingBufferProvider;
137 let provider = provider.as_deserializing();
138 names
139 .as_mut()
140 .load_time_zone_specific_short_names_with_fallback(
141 &provider
142 )?;
143 Ok(())
144 },
145 |names, field_set| names.try_into_formatter_with_buffer_provider(
146 &provider,
147 field_set
148 ),
149 )
150 }
151
152 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_long")]
153 #[cfg(feature = "compiled_data")]
154 pub fn create_localized_offset_long(
155 locale: &Locale,
156 formatter: &DateTimeFormatter,
157 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
158 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetLong;
159 datetime_helpers::datetime_formatter_with_zone(
160 &formatter.0,
161 locale,
162 zone,
163 |names| {
164 names
165 .as_mut()
166 .include_time_zone_localized_offset_names_with_fallback(
167 )?;
168 Ok(())
169 },
170 |names, field_set| names.try_into_formatter(
171 field_set
172 ),
173 )
174 }
175
176 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_long_with_provider")]
177 #[cfg(feature = "buffer_provider")]
178 pub fn create_localized_offset_long_with_provider(
179 provider: &DataProvider,
180 locale: &Locale,
181 formatter: &DateTimeFormatter,
182 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
183 let provider = provider.get()?;
184 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetLong;
185 datetime_helpers::datetime_formatter_with_zone(
186 &formatter.0,
187 locale,
188 zone,
189 |names| {
190 use icu_provider::buf::AsDeserializingBufferProvider;
191 let provider = provider.as_deserializing();
192 names
193 .as_mut()
194 .load_time_zone_localized_offset_names_with_fallback(
195 &provider
196 )?;
197 Ok(())
198 },
199 |names, field_set| names.try_into_formatter_with_buffer_provider(
200 &provider,
201 field_set
202 ),
203 )
204 }
205
206 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_short")]
207 #[cfg(feature = "compiled_data")]
208 pub fn create_localized_offset_short(
209 locale: &Locale,
210 formatter: &DateTimeFormatter,
211 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
212 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetShort;
213 datetime_helpers::datetime_formatter_with_zone(
214 &formatter.0,
215 locale,
216 zone,
217 |names| {
218 names
219 .as_mut()
220 .include_time_zone_localized_offset_names_with_fallback(
221 )?;
222 Ok(())
223 },
224 |names, field_set| names.try_into_formatter(
225 field_set
226 ),
227 )
228 }
229
230 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_short_with_provider")]
231 #[cfg(feature = "buffer_provider")]
232 pub fn create_localized_offset_short_with_provider(
233 provider: &DataProvider,
234 locale: &Locale,
235 formatter: &DateTimeFormatter,
236 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
237 let provider = provider.get()?;
238 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetShort;
239 datetime_helpers::datetime_formatter_with_zone(
240 &formatter.0,
241 locale,
242 zone,
243 |names| {
244 use icu_provider::buf::AsDeserializingBufferProvider;
245 let provider = provider.as_deserializing();
246 names
247 .as_mut()
248 .load_time_zone_localized_offset_names_with_fallback(
249 &provider
250 )?;
251 Ok(())
252 },
253 |names, field_set| names.try_into_formatter_with_buffer_provider(
254 &provider,
255 field_set
256 ),
257 )
258 }
259
260 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_long")]
261 #[cfg(feature = "compiled_data")]
262 pub fn create_generic_long(
263 locale: &Locale,
264 formatter: &DateTimeFormatter,
265 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
266 let zone = icu_datetime::fieldsets::zone::GenericLong;
267 datetime_helpers::datetime_formatter_with_zone(
268 &formatter.0,
269 locale,
270 zone,
271 |names| {
272 names
273 .as_mut()
274 .include_time_zone_generic_long_names_with_fallback(
275 )?;
276 Ok(())
277 },
278 |names, field_set| names.try_into_formatter(
279 field_set
280 ),
281 )
282 }
283
284 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_long_with_provider")]
285 #[cfg(feature = "buffer_provider")]
286 pub fn create_generic_long_with_provider(
287 provider: &DataProvider,
288 locale: &Locale,
289 formatter: &DateTimeFormatter,
290 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
291 let provider = provider.get()?;
292 let zone = icu_datetime::fieldsets::zone::GenericLong;
293 datetime_helpers::datetime_formatter_with_zone(
294 &formatter.0,
295 locale,
296 zone,
297 |names| {
298 use icu_provider::buf::AsDeserializingBufferProvider;
299 let provider = provider.as_deserializing();
300 names
301 .as_mut()
302 .load_time_zone_generic_long_names_with_fallback(
303 &provider
304 )?;
305 Ok(())
306 },
307 |names, field_set| names.try_into_formatter_with_buffer_provider(
308 &provider,
309 field_set
310 ),
311 )
312 }
313
314 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_short")]
315 #[diplomat::demo(default_constructor)]
316 #[cfg(feature = "compiled_data")]
317 pub fn create_generic_short(
318 locale: &Locale,
319 formatter: &DateTimeFormatter,
320 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
321 let zone = icu_datetime::fieldsets::zone::GenericShort;
322 datetime_helpers::datetime_formatter_with_zone(
323 &formatter.0,
324 locale,
325 zone,
326 |names| {
327 names
328 .as_mut()
329 .include_time_zone_generic_short_names_with_fallback(
330 )?;
331 Ok(())
332 },
333 |names, field_set| names.try_into_formatter(
334 field_set
335 ),
336 )
337 }
338
339 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_short_with_provider")]
340 #[cfg(feature = "buffer_provider")]
341 pub fn create_generic_short_with_provider(
342 provider: &DataProvider,
343 locale: &Locale,
344 formatter: &DateTimeFormatter,
345 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
346 let provider = provider.get()?;
347 let zone = icu_datetime::fieldsets::zone::GenericShort;
348 datetime_helpers::datetime_formatter_with_zone(
349 &formatter.0,
350 locale,
351 zone,
352 |names| {
353 use icu_provider::buf::AsDeserializingBufferProvider;
354 let provider = provider.as_deserializing();
355 names
356 .as_mut()
357 .load_time_zone_generic_short_names_with_fallback(
358 &provider
359 )?;
360 Ok(())
361 },
362 |names, field_set| names.try_into_formatter_with_buffer_provider(
363 &provider,
364 field_set
365 ),
366 )
367 }
368
369 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "location")]
370 #[cfg(feature = "compiled_data")]
371 pub fn create_location(
372 locale: &Locale,
373 formatter: &DateTimeFormatter,
374 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
375 let zone = icu_datetime::fieldsets::zone::Location;
376 datetime_helpers::datetime_formatter_with_zone(
377 &formatter.0,
378 locale,
379 zone,
380 |names| {
381 names
382 .as_mut()
383 .include_time_zone_location_names(
384 )?;
385 Ok(())
386 },
387 |names, field_set| names.try_into_formatter(
388 field_set
389 ),
390 )
391 }
392
393 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "location_with_provider")]
394 #[cfg(feature = "buffer_provider")]
395 pub fn create_location_with_provider(
396 provider: &DataProvider,
397 locale: &Locale,
398 formatter: &DateTimeFormatter,
399 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
400 let provider = provider.get()?;
401 let zone = icu_datetime::fieldsets::zone::Location;
402 datetime_helpers::datetime_formatter_with_zone(
403 &formatter.0,
404 locale,
405 zone,
406 |names| {
407 use icu_provider::buf::AsDeserializingBufferProvider;
408 let provider = provider.as_deserializing();
409 names
410 .as_mut()
411 .load_time_zone_location_names(
412 &provider
413 )?;
414 Ok(())
415 },
416 |names, field_set| names.try_into_formatter_with_buffer_provider(
417 &provider,
418 field_set
419 ),
420 )
421 }
422
423 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "exemplar_city")]
424 #[cfg(feature = "compiled_data")]
425 pub fn create_exemplar_city(
426 locale: &Locale,
427 formatter: &DateTimeFormatter,
428 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
429 let zone = icu_datetime::fieldsets::zone::ExemplarCity;
430 datetime_helpers::datetime_formatter_with_zone(
431 &formatter.0,
432 locale,
433 zone,
434 |names| {
435 names
436 .as_mut()
437 .include_time_zone_exemplar_city_names(
438 )?;
439 Ok(())
440 },
441 |names, field_set| names.try_into_formatter(
442 field_set
443 ),
444 )
445 }
446
447 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "exemplar_city_with_provider")]
448 #[cfg(feature = "buffer_provider")]
449 pub fn create_exemplar_city_with_provider(
450 provider: &DataProvider,
451 locale: &Locale,
452 formatter: &DateTimeFormatter,
453 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
454 let provider = provider.get()?;
455 let zone = icu_datetime::fieldsets::zone::ExemplarCity;
456 datetime_helpers::datetime_formatter_with_zone(
457 &formatter.0,
458 locale,
459 zone,
460 |names| {
461 use icu_provider::buf::AsDeserializingBufferProvider;
462 let provider = provider.as_deserializing();
463 names
464 .as_mut()
465 .load_time_zone_exemplar_city_names(
466 &provider
467 )?;
468 Ok(())
469 },
470 |names, field_set| names.try_into_formatter_with_buffer_provider(
471 &provider,
472 field_set
473 ),
474 )
475 }
476
477 #[diplomat::rust_link(icu::datetime::DateTimeFormatter::format, FnInStruct)]
478 #[diplomat::rust_link(icu::datetime::FormattedDateTime, Struct, hidden)]
479 #[diplomat::rust_link(icu::datetime::FormattedDateTime::to_string, FnInStruct, hidden)]
480 pub fn format_iso(
481 &self,
482 date: &IsoDate,
483 time: &Time,
484 zone: &TimeZoneInfo,
485 write: &mut diplomat_runtime::DiplomatWrite,
486 ) -> Result<(), DateTimeWriteError> {
487 let mut input = icu_datetime::DateTimeInputUnchecked::default();
488 let date = date.0.to_calendar(self.0.calendar());
489 input.set_date_fields(date);
490 input.set_time_fields(time.0);
491 input.set_time_zone_id(zone.time_zone_id);
492 if let Some(offset) = zone.offset {
493 input.set_time_zone_utc_offset(offset);
494 }
495 if let Some(local_time) = zone.local_time {
496 input.set_time_zone_local_time(local_time);
497 }
498 if let Some(zone_variant) = zone.zone_variant {
499 input.set_time_zone_variant(zone_variant);
500 }
501 let _infallible = self
502 .0
503 .format_unchecked(input)
504 .try_write_to(write)
505 .ok()
506 .transpose()?;
507 Ok(())
508 }
509 }
510
511
512 #[diplomat::opaque]
513 #[diplomat::rust_link(icu::datetime::FixedCalendarDateTimeFormatter, Typedef)]
514 pub struct ZonedDateTimeFormatterGregorian(
515 pub icu_datetime::FixedCalendarDateTimeFormatter<
516 Gregorian,
517 icu_datetime::fieldsets::enums::ZonedDateAndTimeFieldSet
518 >,
519 );
520
521 impl ZonedDateTimeFormatterGregorian {
522 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_long")]
523 #[cfg(feature = "compiled_data")]
524 pub fn create_specific_long(
525 locale: &Locale,
526 formatter: &DateTimeFormatterGregorian,
527 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
528 let zone = icu_datetime::fieldsets::zone::SpecificLong;
529 datetime_helpers::datetime_formatter_gregorian_with_zone(
530 &formatter.0,
531 locale,
532 zone,
533 |names| {
534 names
535 .include_time_zone_specific_long_names_with_fallback(
536 )?;
537 Ok(())
538 },
539 |names, field_set| names.try_into_formatter(
540 field_set
541 ),
542 )
543 }
544
545 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_long_with_provider")]
546 #[cfg(feature = "buffer_provider")]
547 pub fn create_specific_long_with_provider(
548 provider: &DataProvider,
549 locale: &Locale,
550 formatter: &DateTimeFormatterGregorian,
551 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
552 let provider = provider.get()?;
553 let zone = icu_datetime::fieldsets::zone::SpecificLong;
554 datetime_helpers::datetime_formatter_gregorian_with_zone(
555 &formatter.0,
556 locale,
557 zone,
558 |names| {
559 use icu_provider::buf::AsDeserializingBufferProvider;
560 let provider = provider.as_deserializing();
561 names
562 .load_time_zone_specific_long_names_with_fallback(
563 &provider
564 )?;
565 Ok(())
566 },
567 |names, field_set| names.try_into_formatter_with_buffer_provider(
568 &provider,
569 field_set
570 ),
571 )
572 }
573
574 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_short")]
575 #[cfg(feature = "compiled_data")]
576 pub fn create_specific_short(
577 locale: &Locale,
578 formatter: &DateTimeFormatterGregorian,
579 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
580 let zone = icu_datetime::fieldsets::zone::SpecificShort;
581 datetime_helpers::datetime_formatter_gregorian_with_zone(
582 &formatter.0,
583 locale,
584 zone,
585 |names| {
586 names
587 .include_time_zone_specific_short_names_with_fallback(
588 )?;
589 Ok(())
590 },
591 |names, field_set| names.try_into_formatter(
592 field_set
593 ),
594 )
595 }
596
597 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "specific_short_with_provider")]
598 #[cfg(feature = "buffer_provider")]
599 pub fn create_specific_short_with_provider(
600 provider: &DataProvider,
601 locale: &Locale,
602 formatter: &DateTimeFormatterGregorian,
603 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
604 let provider = provider.get()?;
605 let zone = icu_datetime::fieldsets::zone::SpecificShort;
606 datetime_helpers::datetime_formatter_gregorian_with_zone(
607 &formatter.0,
608 locale,
609 zone,
610 |names| {
611 use icu_provider::buf::AsDeserializingBufferProvider;
612 let provider = provider.as_deserializing();
613 names
614 .load_time_zone_specific_short_names_with_fallback(
615 &provider
616 )?;
617 Ok(())
618 },
619 |names, field_set| names.try_into_formatter_with_buffer_provider(
620 &provider,
621 field_set
622 ),
623 )
624 }
625
626 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_long")]
627 #[cfg(feature = "compiled_data")]
628 pub fn create_localized_offset_long(
629 locale: &Locale,
630 formatter: &DateTimeFormatterGregorian,
631 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
632 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetLong;
633 datetime_helpers::datetime_formatter_gregorian_with_zone(
634 &formatter.0,
635 locale,
636 zone,
637 |names| {
638 names
639 .include_time_zone_localized_offset_names_with_fallback(
640 )?;
641 Ok(())
642 },
643 |names, field_set| names.try_into_formatter(
644 field_set
645 ),
646 )
647 }
648
649 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_long_with_provider")]
650 #[cfg(feature = "buffer_provider")]
651 pub fn create_localized_offset_long_with_provider(
652 provider: &DataProvider,
653 locale: &Locale,
654 formatter: &DateTimeFormatterGregorian,
655 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
656 let provider = provider.get()?;
657 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetLong;
658 datetime_helpers::datetime_formatter_gregorian_with_zone(
659 &formatter.0,
660 locale,
661 zone,
662 |names| {
663 use icu_provider::buf::AsDeserializingBufferProvider;
664 let provider = provider.as_deserializing();
665 names
666 .load_time_zone_localized_offset_names_with_fallback(
667 &provider
668 )?;
669 Ok(())
670 },
671 |names, field_set| names.try_into_formatter_with_buffer_provider(
672 &provider,
673 field_set
674 ),
675 )
676 }
677
678 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_short")]
679 #[cfg(feature = "compiled_data")]
680 pub fn create_localized_offset_short(
681 locale: &Locale,
682 formatter: &DateTimeFormatterGregorian,
683 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
684 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetShort;
685 datetime_helpers::datetime_formatter_gregorian_with_zone(
686 &formatter.0,
687 locale,
688 zone,
689 |names| {
690 names
691 .include_time_zone_localized_offset_names_with_fallback(
692 )?;
693 Ok(())
694 },
695 |names, field_set| names.try_into_formatter(
696 field_set
697 ),
698 )
699 }
700
701 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "localized_offset_short_with_provider")]
702 #[cfg(feature = "buffer_provider")]
703 pub fn create_localized_offset_short_with_provider(
704 provider: &DataProvider,
705 locale: &Locale,
706 formatter: &DateTimeFormatterGregorian,
707 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
708 let provider = provider.get()?;
709 let zone = icu_datetime::fieldsets::zone::LocalizedOffsetShort;
710 datetime_helpers::datetime_formatter_gregorian_with_zone(
711 &formatter.0,
712 locale,
713 zone,
714 |names| {
715 use icu_provider::buf::AsDeserializingBufferProvider;
716 let provider = provider.as_deserializing();
717 names
718 .load_time_zone_localized_offset_names_with_fallback(
719 &provider
720 )?;
721 Ok(())
722 },
723 |names, field_set| names.try_into_formatter_with_buffer_provider(
724 &provider,
725 field_set
726 ),
727 )
728 }
729
730 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_long")]
731 #[cfg(feature = "compiled_data")]
732 pub fn create_generic_long(
733 locale: &Locale,
734 formatter: &DateTimeFormatterGregorian,
735 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
736 let zone = icu_datetime::fieldsets::zone::GenericLong;
737 datetime_helpers::datetime_formatter_gregorian_with_zone(
738 &formatter.0,
739 locale,
740 zone,
741 |names| {
742 names
743 .include_time_zone_generic_long_names_with_fallback(
744 )?;
745 Ok(())
746 },
747 |names, field_set| names.try_into_formatter(
748 field_set
749 ),
750 )
751 }
752
753 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_long_with_provider")]
754 #[cfg(feature = "buffer_provider")]
755 pub fn create_generic_long_with_provider(
756 provider: &DataProvider,
757 locale: &Locale,
758 formatter: &DateTimeFormatterGregorian,
759 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
760 let provider = provider.get()?;
761 let zone = icu_datetime::fieldsets::zone::GenericLong;
762 datetime_helpers::datetime_formatter_gregorian_with_zone(
763 &formatter.0,
764 locale,
765 zone,
766 |names| {
767 use icu_provider::buf::AsDeserializingBufferProvider;
768 let provider = provider.as_deserializing();
769 names
770 .load_time_zone_generic_long_names_with_fallback(
771 &provider
772 )?;
773 Ok(())
774 },
775 |names, field_set| names.try_into_formatter_with_buffer_provider(
776 &provider,
777 field_set
778 ),
779 )
780 }
781
782 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_short")]
783 #[diplomat::demo(default_constructor)]
784 #[cfg(feature = "compiled_data")]
785 pub fn create_generic_short(
786 locale: &Locale,
787 formatter: &DateTimeFormatterGregorian,
788 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
789 let zone = icu_datetime::fieldsets::zone::GenericShort;
790 datetime_helpers::datetime_formatter_gregorian_with_zone(
791 &formatter.0,
792 locale,
793 zone,
794 |names| {
795 names
796 .include_time_zone_generic_short_names_with_fallback(
797 )?;
798 Ok(())
799 },
800 |names, field_set| names.try_into_formatter(
801 field_set
802 ),
803 )
804 }
805
806 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "generic_short_with_provider")]
807 #[cfg(feature = "buffer_provider")]
808 pub fn create_generic_short_with_provider(
809 provider: &DataProvider,
810 locale: &Locale,
811 formatter: &DateTimeFormatterGregorian,
812 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
813 let provider = provider.get()?;
814 let zone = icu_datetime::fieldsets::zone::GenericShort;
815 datetime_helpers::datetime_formatter_gregorian_with_zone(
816 &formatter.0,
817 locale,
818 zone,
819 |names| {
820 use icu_provider::buf::AsDeserializingBufferProvider;
821 let provider = provider.as_deserializing();
822 names
823 .load_time_zone_generic_short_names_with_fallback(
824 &provider
825 )?;
826 Ok(())
827 },
828 |names, field_set| names.try_into_formatter_with_buffer_provider(
829 &provider,
830 field_set
831 ),
832 )
833 }
834
835 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "location")]
836 #[cfg(feature = "compiled_data")]
837 pub fn create_location(
838 locale: &Locale,
839 formatter: &DateTimeFormatterGregorian,
840 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
841 let zone = icu_datetime::fieldsets::zone::Location;
842 datetime_helpers::datetime_formatter_gregorian_with_zone(
843 &formatter.0,
844 locale,
845 zone,
846 |names| {
847 names
848 .include_time_zone_location_names(
849 )?;
850 Ok(())
851 },
852 |names, field_set| names.try_into_formatter(
853 field_set
854 ),
855 )
856 }
857
858 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "location_with_provider")]
859 #[cfg(feature = "buffer_provider")]
860 pub fn create_location_with_provider(
861 provider: &DataProvider,
862 locale: &Locale,
863 formatter: &DateTimeFormatterGregorian,
864 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
865 let provider = provider.get()?;
866 let zone = icu_datetime::fieldsets::zone::Location;
867 datetime_helpers::datetime_formatter_gregorian_with_zone(
868 &formatter.0,
869 locale,
870 zone,
871 |names| {
872 use icu_provider::buf::AsDeserializingBufferProvider;
873 let provider = provider.as_deserializing();
874 names
875 .load_time_zone_location_names(
876 &provider
877 )?;
878 Ok(())
879 },
880 |names, field_set| names.try_into_formatter_with_buffer_provider(
881 &provider,
882 field_set
883 ),
884 )
885 }
886
887 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "exemplar_city")]
888 #[cfg(feature = "compiled_data")]
889 pub fn create_exemplar_city(
890 locale: &Locale,
891 formatter: &DateTimeFormatterGregorian,
892 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
893 let zone = icu_datetime::fieldsets::zone::ExemplarCity;
894 datetime_helpers::datetime_formatter_gregorian_with_zone(
895 &formatter.0,
896 locale,
897 zone,
898 |names| {
899 names
900 .include_time_zone_exemplar_city_names(
901 )?;
902 Ok(())
903 },
904 |names, field_set| names.try_into_formatter(
905 field_set
906 ),
907 )
908 }
909
910 #[diplomat::attr(all(supports = fallible_constructors, supports = named_constructors), named_constructor = "exemplar_city_with_provider")]
911 #[cfg(feature = "buffer_provider")]
912 pub fn create_exemplar_city_with_provider(
913 provider: &DataProvider,
914 locale: &Locale,
915 formatter: &DateTimeFormatterGregorian,
916 ) -> Result<Box<Self>, DateTimeFormatterLoadError> {
917 let provider = provider.get()?;
918 let zone = icu_datetime::fieldsets::zone::ExemplarCity;
919 datetime_helpers::datetime_formatter_gregorian_with_zone(
920 &formatter.0,
921 locale,
922 zone,
923 |names| {
924 use icu_provider::buf::AsDeserializingBufferProvider;
925 let provider = provider.as_deserializing();
926 names
927 .load_time_zone_exemplar_city_names(
928 &provider
929 )?;
930 Ok(())
931 },
932 |names, field_set| names.try_into_formatter_with_buffer_provider(
933 &provider,
934 field_set
935 ),
936 )
937 }
938
939 #[diplomat::rust_link(icu::datetime::FixedCalendarDateTimeFormatter::format, FnInStruct)]
940 #[diplomat::rust_link(icu::datetime::FormattedDateTime, Struct, hidden)]
941 #[diplomat::rust_link(icu::datetime::FormattedDateTime::to_string, FnInStruct, hidden)]
942 pub fn format_iso(
943 &self,
944 date: &IsoDate,
945 time: &Time,
946 zone: &TimeZoneInfo,
947 write: &mut diplomat_runtime::DiplomatWrite,
948 ) -> Result<(), DateTimeWriteError> {
949 let mut input = icu_datetime::DateTimeInputUnchecked::default();
950 let date = date.0.to_calendar(Gregorian);
951 input.set_date_fields(date);
952 input.set_time_fields(time.0);
953 input.set_time_zone_id(zone.time_zone_id);
954 if let Some(offset) = zone.offset {
955 input.set_time_zone_utc_offset(offset);
956 }
957 if let Some(local_time) = zone.local_time {
958 input.set_time_zone_local_time(local_time);
959 }
960 if let Some(zone_variant) = zone.zone_variant {
961 input.set_time_zone_variant(zone_variant);
962 }
963 let _infallible = self
964 .0
965 .format_unchecked(input)
966 .try_write_to(write)
967 .ok()
968 .transpose()?;
969 Ok(())
970 }
971 }
972
973}