Files
archy/core/target/debug/deps/libicu_provider-8143c83cab886369.rmeta
T

2093 lines
329 KiB
Plaintext
Raw Normal View History

2026-01-24 22:59:20 +00:00
rust
s##rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼§Ì±-a7a40eb546f9e2b0ÁzerotrieÁw²ø#{{çbKåDŽJ´-f10a0af380abd751Á
displaydocÁà¿ÿ©]n´ùRèê]-8a7302fc0e16b6baÁzerofromÁˆo“ÄÄx(ÃjBsÖ›ªÅ-e7a4aaab09db7e3aÁzerofrom_deriveÁ¿ &èé•)ˆç-03b1dd1f2d87713aÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6ÁyokeÁÓ\¾^Œ†ícN¼è¸¼bH-17a2be691e559186Ástable_deref_traitÁþÖ›#Ÿžõ E4Õèr-80e318edb62c0e9cÁ yoke_deriveÁ­Ù@÷ò+çšFåcz-5e7d4687001d5481ÁzerovecÁ9°I=µá’Ún÷£ø×ªwÓ-187d4334a3106b07Ázerovec_deriveÁ44½é—FsÉR-*±È-f6b5d17a820a0cf7Á writeableÁ³®ç‘"0Äز¿.áÆˆÂ-5a4fe1098e64be2fÁicu_locale_coreÁ
þ I왈ñ7Âp~-e924512d9672dc67ÁlitemapÁ#àG½ÆàÍ §ßëûvFÜ-6c0049c0b6db37f9ÁtinystrÁEM¤ƒC
ý¶s·5CO¾U-76a3ce4936fcb599Áá,€%<ß$á<é$Œß$£ $¤
áŒê 8serdeÁ,½àŒ¥exportÁ4ˆ&<ë%ƒDõ%”ë% hello_worldÁ\²&<&á< &Œ–&serde_borrow_de_utilsÁ¬¯'<ð&à<ú&Œð&NIterableDataProviderÁ¤Ÿ<á<ŒNIterableDynamicDataProviderÁܨD<ŠDá<”DŒŠDNà$¦eà$›eƒ¤§)<û(á<…)Œû(µܽ)á²øáŒÑ²œá<Œƒ²BoxÁßጹ²4áŒê²Õጟ²VarULEÁ4å<¿áŒ¿²DataIdentifierCowÁŒÆ!<§!á<±!Œ§!Ôø àጺÔ< áŒ Ô
SelectedRcÁTÔ<á<—ŒÔë áŒæÔ CartInnerÁL„0<à/á<ê/Œà/ß ZeroMapKVÁL”áŒìßZeroMapÁ<Ÿ&á$" ZeroMap2dÁL¨HáFDMaybeEncodeAsVarULEÁœ‚
ƒ”ã ëÅ
œ 2<é1ƒDó1”é1íAsDeserializingBufferProviderÁìÝ3<±3à<»3Œ±3íý
Œœ9<Ì8á<Ö8ŒÌ8탤¯9áíµÜÅ98á646logÁá;<Ã;loggingÁLÍ;œÃ;¢ý<<Å<á<Ï<ŒÅ<³bakedÁ_ ID_SEPARATORÁ get_indexÁfrom_trie_and_values_uncheckedÁÕÕgetÁ Õfrom_trie_and_refs_uncheckedÁÕÕ˜ DataForVarULEsÁ"Õ"trieÁ"&Õ(Õ(Ý+Õ+˜-  DataStoreÁ3Õ3˜privateÁ6SealedÁbufÁ88:
DataStructÁ8BufferProviderÁ8=8?check_availableÁ constructorsÁAgen_buffer_unstable_docsÁAgen_buffer_data_constructorsÁdynutilÁDUpcastDataPayloadÁEÕEupcastÁD__impl_casting_upcastÁDD__impl_dynamic_data_providerÁDD%__impl_iterable_dynamic_data_providerÁD
data_providerÁNNNN DataProviderÁRÕRÙ NUÕUÛUÙ NDryDataProviderÁYÕYdry_loadÁN\Õ\Û\úNDynamicDataProviderÁ`Õ` load_dataÁNcÕcÛcÃNDynamicDryDataProviderÁgÕg
dry_load_dataÁNjÕjÛjNBoundDataProviderÁnÕn
load_boundÁn bound_markerÁNrÕrÛrÜríNwÕwÛw N{Õ{M0Á{{Û{'aÁ{Ü{íerrorÁŠŠŠŠŠŠŠÍŠ
into_errorÁ with_markerÁwith_str_contextÁwith_type_contextÁwith_reqÁŠšcustomÁšÞšñšžšªšwith_display_contextÁ¡šwith_debug_contextÁ£šfor_typeÁ¥ŠŠResultDataErrorÁ¨¨allow_identifier_not_foundÁŠ««ø 
 requestÁ²²²²²²²¹Í²»Ü»
for_localeÁ»for_marker_attributesÁ» for_marker_attributes_and_localeÁ²À>²ÂšÂ²ÅͲÇvalidateÁÇ try_from_strÁÇ
try_from_utf8ÁÇfrom_str_or_panicÁÇemptyÁÇ 
responseÁÔÔÔÔÔÔÔÔÔÝ
with_checksumÁÔ DataPayloadÁß
ßÕßìÔ
DataPayloadOrÁã
ãÕããìÔDataPayloadInnerÁèÕèYokeÁê
êìè StaticRefÁí
íìÔDataPayloadOrInnerÁðÕð©!ðÚ!ó
óìðInnerÁö
öìÔDataPayloadOrInnerInnerÁùÕù©!ùó!ü
üìùOtherÁÿ
ÿìÔ³ ÔÔ unwrap_cartÁÍÜ ˆ ÔŠÕŠÜŠÍÔŽÕŽ©!ŽÜŽÍ  ÔÕÜÈÔÕ©!ÜÈԞ՞ܞÕÔ¢Õ¢©!¢Ü¢ÕÔ §Õ§ÜÔ
ªÕª©!ªÜÔ ®Õ®
from_ownedÁ®from_static_refÁ®with_mutÁ²Ü²²'bÁ®˜Ü®
get_staticÁ® map_projectÁ¹M2Á¹×&¹Ü®map_project_clonedÁ½'thisÁ½Ÿ'½×&½Ü®try_map_projectÁŸ'Â×&ÂÂÜ®try_map_project_clonedÁÇÓ'ÇŸ'Ç×&ÇŸ(ÇÜ®castÁÍŸ'®cast_refÁÏŸ'® dynamic_castÁÑŸ'®dynamic_cast_mutÁÓŸ'Ô Õfrom_yoked_bufferÁÕfrom_static_bufferÁÔ
ØÕØ>ÔÛÕÛ©!Û from_payloadÁÛ
from_otherÁÛ
is_payloadÁÛ˜áÜÛ
into_innerÁÔäÕä¾ ä
get_optionÁçÜÔ DataResponseÁéÕémetadataÁépayloadÁÔíÕíö(ïŸ'í¢)ñŸ'ÔóÕóÜóÍÔ÷Õ÷Ü÷È marker_fullÁ 
  
DynamicDataMarker籆
DataMarkerÁINFOÁ
DataMarkerExtÁbindÁÛ make_localeÁÕ¶.ÛÊ.žÍžÜž±¢Í¢Ü¢•.!__impl_data_provider_never_markerÁ¨ LEADING_TAGÁ¨to_bytesÁª  fxhash_32Á¬ hash_word_32Á­ROTATEÁ­SEED32Á°ULEÁ° to_unalignedÁ°from_unalignedÁµÕ·Ð¹¤  »¢¼
¾ from_nameÁ¾hashedÁ Á¤  ÃÐ
Å¢ÆË1Èfrom_idÁÈ match_markerÁÈÊ. data_markerÁÍÍϱÏÜϱ
×××××××
varule_traitsÁßß
MaybeAsVarULEÁá
EncodedStructÁß data_structÁßääÍä äü3ßéü3uleÁëâ íííííííííí í
í í í
íííííííííííííííí³Œ>Œ>Œ>Œ>¢_internal_noop_logÁDataÁœÕœœ  Õ ÍDataRefÁ£Õ££
§Õ§Í8 BufferMarkerÁª
8¬Í8 BufferFormatÁ®JsonÁ¯
®Bincode1Á±
® Postcard1Á³
8µÍ88¸Õ8º˜8¼¢½µ8 8
8 ÁÈNDataProviderWithMarkerÁÃÕÃÛÃinnerÁÃ_markerÁNÈÕÈÛÈÍŠ
DataErrorKindÁŠŠÎÈŠŠÑ˜Š Š
ÔÕŠÖ×ÍŠ ÙÍÌMarkerNotFoundÁÛ
ÌIdentifierNotFoundÁÝ
ÌInvalidRequestÁß
ÌInconsistentDataÁá
áìÌDowncastÁä
äìÌ DeserializeÁç
ÌCustomÁé
Š DataErrorÁë¯ ë
ë str_contextÁësilentÁŠ Š
ñÈŠŠô˜ŠŠ÷ÕŠùͲ DataRequestÁûÜûidÁûä+²ÿÜÿ>²ÜͲܲ ÜȲ
ŠÜ² ŒÜ² ŽÜŽÕ²
ܘ²DataRequestMetadataÁë<attributes_prefix_matchÁ²>²Í²²œÈ²²² Õ²¢˜²¤¤ ²¦Ð²DataIdentifierBorrowedÁ¨Ü¨marker_attributesÁ¨localeÁ²¬Ü¬>²¯Ü¯Í²²Ü²´Ü´È²·Ü²¹Ü²»Ü»Õ²¾Ü¾˜²DataMarkerAttributesÁÁ˜² ²!ÄÕ²"Ƙ²#Èв$ʤ ²%̢͵²AttributeParseErrorÁÏ
²&ÑÍÔDataResponseMetadataÁÓâ@Ó
buffer_formatÁÓchecksumÁÔ×ÍÔÙÈÔÔÜÕÔÞ>ÔCartÁà
àìÔãÈÔåÍ NeverMarkerÁç
çÍçìëÍëÍîÍðÍðÈDataMarkerIdHashÁó
óìõ ÷ÍúÕü˜ý ÿ¤ ÐÈ ˆ¢µvalidate_bytesÁŒSIZEÁŒZEROÁŒSIZE_0Á ŒOFFSET_0ÁŒ  DataMarkerIdÁã¢ Í !"Èœ #ž˜Ÿ DataMarkerInfoÁ¡×=¡ is_singletonÁ¡ has_checksumÁ¡fallback_configÁ$%&¨È'(«Õ)­˜ ErasedMarkerÁ¯
¯±¯Ü¯ì*´±´Ü´È+¸±¸Ü,»±»Ü-¾±¾Ü¾Õ.±Âܘ/ƱÆÜƢɵ0˱ËÜËÍŒLocaleFallbackPriorityÁÏLanguageÁÐ
ÏScriptÁÒ
ÏRegionÁÔ
ŒÖÍŒŒÙՌۘŒŒ Œ
ßÈŒ ᤠŒ ãÐŒLocaleFallbackConfigÁåpriorityÁŒ
çÍŒŒêÈŒŒíՌ




-
-
5
5
@
T
T
U
X
X
[
[
\
_
_
b
b
c
f
f
i
i
j
m
m
p
p
q
r
u
u
v







 
¡
£
¹
º
º
º
À
Ä
Æ
Æ
Æ
È
É
Ê
Ë
Í






˜

¡
¡
¦
¦
¸
Ï
Ó
à
ö
ö
ö
ú
¬


¸
¸
º
º
¼
¼
Â
Â
Ä
Ä
Æ
Æ
Î
Î
Î
¢
¢
¢
©
©
©
­
­
­



¹
¹
»
½
½
Â
Ë
Ë
Ë
Ï
Ò
Õ
Õ
Ø
Ø
Ø
Ú
Ú
Ú
ò
õ
ø
ø
ú
ú
ú







š
š
š

¡
¡
£
¥
¥
§
§
±
±
±

½
½
À
Å
Å
Ç
É
É
Ë
Ë
Í
Í
Ò
Ò
Ò
Ø
Ø
Ø
Ú
Ý
Ý
ä
æ
æ
æ
í
í
í
ò
ø
ø
ø
û
û
ý







Œ
˜
˜
˜
œ
Ÿ
©
¬
¬
®
·
Á
Á
Å
É
É
Î
Î
Î
×
×
×
Ú
Ú
Ü
à
â
â
ä
ä
è
è
è
ë
î
î
ð
37<ERY`gn¨áà`œœï6žŸpO~(ë-Õ7ÖW3ÖWXà`££¦7¥¦¸…lŒ7x?JX7¯X3¯XX7""õ$%°<*ÚêUX3„YXà`ªª«à7 °fCÁ‡ìÍY<Ûà`®¯°˜8±²©8³´¾8é’9œ°«¬âZžZZ£Z»bZþZáZÞZR 8ÛÕY¤[°[`¤[°[g¤[°[n¤[°[à`Ãã9ÆÑ9NÇÞ9NK7S¹œ¹—XÛnÃã9ÆÑ9NÇÞ9NK7S¹œ¹—XÛÄáÌÛÜõ:ÝÞ;ßà¯;áâÊ;ãìäåï;æìçèŒ<éê¤<ëÁ$\tØiµÞ€]þ€]£€]¬â€]ž€]€]å`€]à`€]áëë·<ì¯ í
îØ<ïë<©6[W~t|Þè^þè^£è^¬âè^žè^è^à`è^å`è^Ïè^¨ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶è^Ö`Äûû¼=ý×=þä+ØÎ†Ë¦XÁ&Üà`é`áé`Þé`þé`¬âé`žé`é`£é`Äø>ë<?%XL:—o.à`óaáóaÞóaþóa¬âóažóaóa£óaÉóaóaÃóaĨ¨£@ªÉ@«â@¼ñ'";LÒµÜà`ŽcáŽcÞŽcþŽc¬âŽcžŽcŽc£Žcå`¨¨£@ªÉ@«â@¼ñ'";LÒµ8¬âÁÁÿA˜²Û©–MR~ažØdØd£ØdÃØdÉØdØd»bØdÄ 8ØdìØdà`Ødà`ÏÏÐñB K<è߬õ30à`ÓÓžCÔâ@ÕÂCÖ×C°‹µ/ïÎXÞ”f¬â”fž”f”fÄ”fÞààáŸDâìÔ 3œ!®þ+à`ƒgÔƒgà`ßßàß âì Ô«|oPŸ¥Xà`ããä‡!çì ÇÓ'eg ËX©!ÞÏgÞ‰hžÏgÏgž‰h‰h£Ïg£‰hÄÏgà`ééÈ+ëä+ìô+MÕRÕs)XÞ•iXà`ççèÒDêì ªð$´«–sõÍþæiÞæiæiæià`óóô±Eõì Ö\A<}Ã¥¬âÌjžÌjÌj£ÌjÉÌjÌjÃÌjþÌjáÌjÞÌj»bÌj
ÄÌj
ÉÌj
ÍÌjà`²Gã¢SÕL«vr|þƒláƒlÞƒl£ƒlžƒlƒlÃlɃlƒl»bƒlþ¡¡–H¢×=£´H¤ÈH¥ÜH«rìêh·¯á™mÞ™m¬â™mž™m™m£™mÉ™m™mÙm»b™mà`™mÞ¯¯°©I³ì d¤÷{#Bdû±þÆn¬âÆnžÆnÆn£Æn»bÆnà`ÆnÆnáÖ`Íáà`ÏÐÑ»KÒÓÐKÔÕãKâ@NîòžÍ¬âèožèoèo£èoþèoáèoÞèoÉèoèoÃèoÄèoà`ååÓLæïLÃçP Y–µá•qÞ•q¬â•qž•q•q£•qþ•qÄ•q œ§£¬ªµ®ÈÃÙÌùëû¯¨ÅÁÑÏ×ÓåàŠßŽãóéëç÷ó͡˯ÖÏç圣&"œ£+":ªžçϯ=·®ÓÌöëŒûŸ¹¨ÃÁÛÓù󪡻¯ØÏì帮ÔÌ÷ëŽû »¨ÄÁÜӞߢãú󵫡¾¯ÙÏí庮ÑÌôëû¢¾¨ÆÁ§ßªãü󞭡¯ÛÏïå¼®ÌÁˆó»Å¡Æ¯¿®ÐÌóëŠûž·¨îçƒó¦¡¸¯ÝÏñåÀ®ÍÌðëû²¨óš§¡ÞÏéåÁ®ÎÌñëûœ´¨ÙÓãàßã÷éðç󨡴¯ßÏêåU
\
c
j
r
{Ã×Ì빨§ë«ê³ÿû¬¨À
ÞÓØßÏå¤ÊÁÿó¹Á¡áϦÈÁó·Ã¡ãÏÂÁƒà¢çó°ó´óäéà`â7¨3<¬â
ž[£p»biþ
*á [ÞMR~Y`gnå`
ϨÄÉ6Ã*ì*Ô
Ä
É
Íá0x1EÁ¬©
œX ½ÄüÃÖW¾¾ZeroTrieSimpleAsciiÁÀ¶Ñè*£ìƒ² 
‡| 
X‹}×Õ}Ë.'ž¬´ 
£X È Ï ü…ʯX‹}$¿ 
Ø}‹} *'Y$¸14¾1¬±1
"X Å1Ì1*üÛ/ñ„Y$¢1}$—0 

 VarZeroSliceÁ



 entire_sliceÁ
Ž6Òßñ’KØ}â
ä 
ä 
å Index16Á ÁÀ;A®Î)4É0‹}怭*Ü,’a\®a
Xüÿ`E
ÃX§\ ÃaÊazüÒ`xí[$ð`§\,ã`§\ŽŠ PhantomDataÁÑ{·Ë…YÚX²Ñ9Jk
$$
ø°ƒl
ø° üã
ë ãêü®¼è^€]€]Àø°ú°û°Ðü°ý°þ°ìHˈXêE>ƒløø°ú°û°Ðü°ý°þ°ìHˈXêE>è„'ªÌŒ„$„
"T‰
/d‰ ü„%

\
œ7œ– ¨¯ü¶yè^€]™mè^Û€]Ú™mœ)
-WŒÈ 
"LJ- Ø üÈ +

„Ú 
}7ÌÚ  ò ù üöƒè^€]$” è„è^Û€]Ú脟+contextÁ5a
¬Í%
Ì$ø%
ø°ƒlŒ—&\œ&
ø°è„ §&ü´%š
ë,¾& Í&Ô&üó$áè^$¥%è„\‡%€]æå…Õ°†Àè„ÀØ<+NL“(€]|²(L·(ƒl
ø°ƒl À(„Ü(°†\‚)üú'ž
ë —)ž)œü±'íè^$ë'è^$Ê'™m4Ð'€]ûå…ìƒlë°†¼ª8
<gLä*€]\ƒ+å…l©+<®+
ø°è„ µ+\Ì+üË*—
ë á+è+üþ)êè^$¼*è^$œ*è„<¢*€]ûå…ì°†Üè„ܬ:­Š>j,ûB ƒC
üŽCÿ \”C ”C<˜C ˜C
$šC
Ýp‡|4,šC žCm~'-üåCŠ ù\~` 
ôC  $òC 
  
 \øC ‡|‡|a   )\á~ 
 
\†D ‡|‡|A  
\”D ‡|‡|0   ‰\~  -_ G V‡|‡|9e ¡ °‡|‡|Z¿  *‡|‡|z: !\Ê~ 
 
º

­D œÌD
ÏÄÈD
ê³èe ßD îD
 µŒE ŒE ¡E¢Ey ïD 
K
Q 4üD E$ 'Jü Cí Ž
 &-øµŽCÿ öüø™E
4E
ê³èe ›E-,6Èü®Bôü÷B«˜ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶èeüÍBÈ} ÀBâÆÁÁÈ}IFC8? ÕÜ07ü¯D@èeÇ=³»ÂœöÌ»²dd»G »G#
*D½G
¹y1T½GM ÆGü§G!

ϤG
Ê' ÇG ÍGÎGÉüÔFzê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ ØdèeüúF"è„ îFÈ}%È}-è„(ö%œÔ±LTÀL
$t±L
È1A ÊLM 4¨L ‰M ÎMTúMüÛM*

ôÛM
¤s4'PœêL
ÏÄæL
ê³É èe ýLüßL „NüÌN- üÕN"
ü×N  |ØN ØN   Ød öN @
 M 
üÉN1
ê³É èe ùN ÿN 
€O ÊüÆKºü¤LÜüÊM¶
ûŸü÷K"È}TáKüÑL8èeLó›È}Ë脼È}¼É ,É ,ç£, ,
code_unitsÁuö
¹¬ÌU ßU
$”ÌU
É1Aù`@#
 á`#
¯Uùa¨"#/ àU ,ÄU ÇUÒÉ  ¨V ²V ¸V¹V)¤
ù·¨"#
×`üüU!è„
ÃËü…U´üÀUy É ,°Uè„ ¤UüçUA&–½–½ ArgumentsÁ˜½templateÁÁ]™½þÁ]¤í¤>ÜIšÐXÉ -ûŸÒè„ÓWö`Î
üâW#üäW!„åWåWè„8ç£ „XXe ŒXXÌüòV›É lŠWÉ ²ç£±î¥°è„°9\ûX ‹YŒYÍüÎX>è„$ìXÉ ,âXè„b6ü÷_!$“`
èX —`üò_'
ßX ˜`Ÿ`±ü¥_zÏg$ã_£$Â_èêëÚ!ììíîó!ïìû¡¨gNqXÜ£ÚdataÁiŠüÓ(ˆdÈ)\É) ‡|7M
l«) è„ Ú)ü»(¡
 ¼»(
É( Û)üž(¿¥™mtª(ƒlØÓ¯ÖѯÖ=}Ú7


˜Ìj#)7BIq
x}
˜‡|Ÿ¥³¾ÅíöŽ<Þ8 !Ž,=O^jîs{ŽŠŽ¡<æ9 ë²(5È} ì9üÇ9'©È},Þ9Öµ{Öµƒ5b"tdmh"Á4Ò:ë²Þ:ªü¡:=ë²<À:Ìj$·: -T«J ¸J
ÃJ,ÉJ\ÉJ
 ÏJú“1,ÏJ ÓJDÞJ éJ
üñJ‰ Œ÷Jd÷J ÷J

4ýJ  . 
?  
 V   K 
{  ‡K$ $—K
ü±Kƒl¿K4ÅK'8 KŒÚKTàK4àK éK= 'cKŒ °ŒùKTÿK4ÿK ˆL= 'cKŒ  °Œ˜LTžL 4žL!!"! §L= "!'
c "K!#Œ$ # $# ° 
‡| ³LüžK—
 ”žK
‘Ëñ
 * ´L µL ÄÆL%$ÓL&&$ÙL''
.
5dÆL
­&B'4%
W ÝL'&ü¿L%%\èL( òL$ ('J(ü‰Kñ  ùL
ÂùLè
ð^ øÂñJ‰* =*CQü€M¬,ŒƒM-dƒM.ƒM//4‰M00.1/0? 1/0V.1 ŽM0/{-. “M-$.$£M2ü½M"3l¾M44ÄM556'7568 765K45ŒÍM8TÓM94ÓM::;: ÜM= ;:'c9;K:<Œ=9< =<9°89 3
‡|48 ÞM84üªM6

ӻM
øÉ3a2) ßM3 àM95üñM>$þM??\„N@$„NAA2@A ŽNAM
TdñM‹Á?^@P>t N@?üêM&>>\šNB ¤N$ B'JBü•M—,  «N2XÏ.¬N,
{
5-;,ü²NUCŒµNDdµNEµNFF4»NGG.HFG? HFGVEH ÀNGF{DE ÅND
$EüØN(I$åNJJ¤ëNKlëNL4ñNMMN'OMN8 ONMKLMaKL þNL
šdØN‹ÁJ¤K–Iº ÿNKJüÑN/II €OMüÇN@C ·/E‡OC
Ú †ODC$O O“O¬üðB£ ü§Jìü¿JÔüÚJ¹ü“KçüŸMP”CÈ},ƒCÅ © È}© j R {M M M B îf Å
ë²Æ
‡|Ä
Ä
Ô
Û
‡|Š
Š
Š
î
«
²
‡|ü ü ü î

$
‡|n n n î   ]]RîùjrySPPPEîiÞoȇ|Ö‡|ÕÕåì‡|é¨Þoî0Šˆˆˆ}î¡ÿô‡|ôô bytesÁŒcursorÁ\ÏD¢wordÁ-

ÉÓ2(ĵI$µI
"\ºI
—Ê04ÆI®
œºI ÌIü®I$ßId×I  âIÌôI$ôI
"dùI
ÞÊ04†J¯
¤ùI ŒJüíI $—J¡J­ü£HþÖHD¹H$ÈHYY÷ÒÑ¢:ÉÓ?jb®Ð¯¹y7ž
0x9e_37_79_b9Á8Á$üÃ^oüÇ^0üÇ^|Ç^$Ç^
$DÌ^÷ž/TÌ^ Õ^t×^T×^$×^  
$Ü^
°y 1,Ü^ à^ W
 ä^y 
'Ÿ
K
   )   =V
^tç^
 k„ç^ ö^²_
 ±_,¿_TÇ_$Ç_
$Ì_¸Ú/ ,Ì_ ¬‘_<_è„!T_$_
$ _¸Ú/, _ ¤_ƒ
 ¥_Ô_
곃lè„ ¦_ §_@G# Ð_tÇ_ Ô_$ '
JKüß_M  üå_'´å_|å_$å_
$Dê_÷ž/ Tê_ ó_,õ_ õ_ ù_= '
cKÍ Ù! ê ! ý
tü_ŒÜ(„ü_B `4`"  `$ "'J"ü` ë`í
õ š ¦øÃß_M$ G$M «`üµ`O&ô¸`'´¸`(|¸`)$¸`**
$D½`÷ž*/)T½` Æ`*,È`+ È`,,-, Ì`= -,'c+-K,Í.)Ù/+.ê /.+ý()+'($Ò`V‡|/' Õ`+)(Dð`1ñ`233è„!23 ö`44I1
24 ÷`42lì`
곃lýÞ1 ø`1 ù`3 ƒa'& îc³#É+Ï)Õ(„a&
D'J&,a5ìša5
©È}$Åa6ÔÌa7|Öa89$Öa::#
*DÛa÷ž:/9TÛaK89 äa:h
oLÌa
¬8|7Œ åa8üÌa(

\ça
‹Ë7¸6lça óa7 ôa9ü‚bæ;$Úb<<üòbk=D„c> Šc??*@56A?@G A@?Z>5?DŽcB ”cCC*D56ECDG EDCZB5CD˜cF žcGG*H56IGHG IHGZF5GD¢cJ ¨cKK*L56MKLG MLKZJ5K<¬cN ±cOO*PO6L PVOpN6O<µcQ ºcRR*SR6L SVR pQ6R<¾cT ÃcUU*VU6L VVU!pT6U<ÇcW ÌcXX*YX6L YVX"pW6X=
‡|>BFJNQTW ÜcWTQNJ F&B,>;
<= çc=<üÿaê
곃lýÞ; èc;6¤5«²X¹UÀRÇOÎKÕGÜCã?ïc# ¿ü»]´ü»_´üŽaáüÁa®Zê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ƒlýÞüé]#è„$Ò]TR ‡|TÈ}Sè„Tè„î1üø^:ýÞŠ è„ è„ n è„o 

è„
îÞ  N øõ È} è„ H H îY  ½ îj
Ù á è Á ¿ ‡|¿ È}¿ è„À ƒ ƒ îñ ø ü×`-ýÞÀè„Áè„ʤÈ}ýë²èèÈ}èÈ}ðè„ëƒl3è„2Ó¯(‡|''7>‡|ÞÞîõ‡|¥¬‡|LL\c‡|‡|¬‡|77F‡|ÑÑàÿ
×»_magicÁC 5¢1 6U ©È}ÉgÓ¯ÅgÓ¯ÁgÓ¯½gÓ¯„ógôgøgüg  €h

T
‡| 
h
 üâg"
ó ƒh ‰hŠhÀüüfŽü´gV Ìj„™gƒl$g‡|‡|;‡|_‡|ƒë²‡|‡|‡|‡|ûSh1Áph2Ášh3ÁÄh4Áî¾wüßw
ìßw
(ü«w¹
¡,šx,»x ãyêyÉüòvø™m$œwƒl‡wƒl³•q§×=<
Ï
ŽüÈ = èoü·!! 
ü·! 
Ž)üš!I
å â! é! üñ x •q$! èou„‚

Ìâ%€]0™m7> 
Ìå%€]0è„8?üÅ,
ßXà)Ïg4ª®<Cü¬(1
ãX¼hä,‰h7ðóôÚ!õìö÷Ð"øìL–¼Š/ÄWX¼hŒ$Â)
èXë(ª®4ŽŽÚ!yokeableÁƒcartÁƒ9­+¼%+}AØ}ððCartableOptionPointerÁòÑ9ó _cartableÁ¶ ÓdÑåÙ  ÛâLƒ*
èXî(ª®4£;B$ë*
ðX¼hô+Þ…7ü†?F,¬+
ðX¼h÷+Þ…7ùüýó!þìÿ®#ì|Ãኸë ÒX¼hŒLœ,
ùX¼hý+“Š7£>E,Ã,
ùX¼h+“Š7¼h>E|ý.
àá%ƒg0™ˆ8?̵&
ç—jè(æi3ŠÑ‚Ñ{·Ë…YÚ—j`gÜÂ8
óô%Ìj0ë²8?üå›9
¯÷n°*Æn5ŠÑ‚Ñ{·Ë…YÚ÷nbi8ADNвÔ×ßë팳Į(
B¯äù4
CŒ¬ý H¬äÔ JÓüü0% L½Œ÷'n£dŠ(R£9´˜(ÃÝ|°(Y¢œÁ(`ˆì´Ú(g·<L÷)믉:l‚*̰Ù|‘*¨±
DataLocaleÁTÃ*
´Ï¸ÿA¤Ï*Áм=\å*ûÑø>œò*Ò‡!lí+ãû‡!äûŸD$,àýß \•,ßþß àþÈ+d¢,éÿžC¤°,Ó¼/ü²0!¦×2\¶ŠÌƒ.T†-Ô–Ht’-¡ÕÚ-Œ¢-Ö‘4\¤
ã½6”•@£@´È¨ÓñBœ¸AÏÓñBÐÓüËòAüË41 `icu_provider` is one of the `ICU4X` components.ÁËü„_\ Unicode's experience with ICU4X's parent projects, ICU4C and ICU4J, led the team to realizeÁüäli that data management is the most critical aspect of deploying internationalization, and that it requiresÁüÑ^[ a high level of customization for the needs of the platform it is embedded in. As a resultÁü°_\ ICU4X comes with a selection of providers that should allow for ICU4X to naturally fit intoÁü<9 different business and technological needs of customers.ÁÍËüÑ\Y `icu_provider` defines traits and structs for transmitting data through the ICU4X localeÁü®RO data pipeline. The primary trait is [`DataProvider`]. It is parameterized by aÁüif [`DataMarker`], which is the type-system-level data identifier. [`DataProvider`] has a single method,ÁüëWT [`DataProvider::load`], which transforms a [`DataRequest`] into a [`DataResponse`].ÁÃËüÇfc - [`DataRequest`] contains selectors to choose a specific variant of the marker, such as a locale.Áü® GD - [`DataResponse`] contains the data if the request was successful.Áö Ëüú OL The most common types required for this crate are included via the prelude:ÁÊ
Ë
 ```ÁüÖ
! use icu_provider::prelude::*;Á
Ú Ëì„  ## Dynamic Data ProvidersÁ¢ Ëü¦ da If the type system cannot be leveraged to load data (such as when dynamically loading from I/O),Áü‹ qn there's another form of the [`DataProvider`]: [`DynamicDataProvider`]. While [`DataProvider`] is parametrizedÁüý da on the type-system level by a [`DataMarker`] (which are distinct types implementing this trait),Áüâ
yv [`DynamicDataProvider`]s are parametrized at runtime by a [`DataMarkerInfo`] struct, which essentially is the runtimeÁüÜ.+ representation of the [`DataMarker`] type.ÁËümj The [`DynamicDataProvider`] is still type-level parametrized by the type that it loads, and there are twoÁüý-* implementations that should be called outÁ«Ëü¯{x - [`DynamicDataProvider<BufferMarker>`], a.k.a. [`BufferProvider`](buf::BufferProvider) returns data as `[u8]` buffers.Á«Ë´¯ ### BufferProviderÁÆËüÊQN These providers are able to return unstructured data typically represented asÁüœXU [`serde`]-serialized buffers. Users can call [`as_deserializing()`] to get an objectÁüõ@= implementing [`DataProvider`] by invoking Serde Deserialize.ÁËüº  Examples of BufferProviders:ÁÛËüßFC - [`FsDataProvider`] reads individual buffers from the filesystem.Áü¦EB - [`BlobDataProvider`] reads buffers from a large in-memory blob.ÁìËÄð ## Provider AdaptersÁËüSP ICU4X offers several built-in modules to combine providers in interesting ways.Áüá>; These can be found in the [`icu_provider_adapters`] crate.Á Ë¼¤ ## Testing ProviderÁ¼ËüÀLI This crate also contains a concrete provider for demonstration purposes:ÁËü‘PM - [`HelloWorldProvider`] returns "hello world" strings in several languages.ÁâËÔæ ## Types and LifetimesÁËü…c` Types compatible with [`Yokeable`] can be passed through the data provider, so long as they areÁüéEB associated with a marker type implementing [`DynamicDataMarker`].Á¯Ëü³`] Data structs should generally have one lifetime argument: `'data`. This lifetime allows dataÁü”%" structs to borrow zero-copy data.ÁºËü¾ol [`FixedProvider`]: https://docs.rs/icu_provider_adapters/latest/fixed/any_payload/struct.FixedProvider.htmlÁü®;8 [`HelloWorldProvider`]: hello_world::HelloWorldProviderÁüê  [`Yokeable`]: yoke::YokeableÁü‹HE [`impl_dynamic_data_provider!`]: dynutil::impl_dynamic_data_providerÁüÔli [`icu_provider_adapters`]: https://docs.rs/icu_provider_adapters/latest/icu_provider_adapters/index.htmlÁüÁyv [`SourceDataProvider`]: https://docs.rs/icu_provider_source/latest/icu_provider_source/struct.SourceDataProvider.htmlÁü»PM [`as_deserializing()`]: buf::AsDeserializingBufferProvider::as_deserializingÁüŒif [`FsDataProvider`]: https://docs.rs/icu_provider_fs/latest/icu_provider_fs/struct.FsDataProvider.htmlÁüöqn [`BlobDataProvider`]: https://docs.rs/icu_provider_blob/latest/icu_provider_blob/struct.BlobDataProvider.htmlÁ8ADNвÔ×ßë팳pqB¯pCŒoH¬nJÓmL½kn£jR£9iÃÝhY¢g`ˆìfg·<e믉:d̰Ùc¨±Y
´Ï¸ÿAXÁм=WûÑø>VÒ‡!Uãû‡!fäûŸDUàýß Tßþß eàþÈ+TéÿžCSÓ¼/R¦×2P̃.NÔ–HM¡ÕÚ-LÖ‘4Kã½6J£@I¨ÓñBHÏÓñBYÐÓÆÉÌl¢%»Š% % Ÿ%8<Ž% %7ø<˜%̈%üËS P This module contains scaffolding for baked providers, typically generated usingÁ
databake.Á­ Ëü±C @ It can be glob-imported, and includes the icu_provider prelude.Áõ Ëüù3 0 This needs the `"baked"` feature to be enabled.Á,ª%36£@´Õ ¨0öƒ.Tí 1ûÔß \ù ß2þþß à2þþ„® üË-* Data stored as as [`ZeroTrieSimpleAscii`]Á £Ú-Œ’ÖZeroFromÁDÊ
 ªÀ5 ç3láá ì•|œ…¾ ò

Ât¹4<
ð×2\ý4Ì
ò‘4\Š5ã
ó¡.lŸ5
ôÚ½Œõ5n
÷T¢6
´
úϸƒ.T¶6
ûÔß \è6ß
þþß à
þþ£dõ6R
ÿÈ+d­7é
ÿÝ|Ñ7Y
¢œý7`
ˆì´’8g
Ù|ª8¨
ˆ±Š|Œ:

Õ$¿:
ŠÃDç:
à7d«4ª
ïà7«
ïñBœ·5Ï
õñBÐ
õ£@´Ý5¨
ö·<Lˆ6ë
ø¯‰:l“6Ì
ù°ÿA¤Â6Á
üЖHtØ6¡
ýÕ¼=\ƒ7û
Ñø>œ˜7
ÒžC¤»7Ó
ƒÔßüúDA This is a valid separator as `DataLocale` will never produce it.Á¿ËÜà Mostly for internal useÁdé‡|Ä‹ ü©H”ÀúÔ”ÜáìûѬžÇü¶ò¾¾•|À¶Ñè*£ìƒ² Ê}¨¨£@ªÉ@«â@¼ñ'";LÒµòø°ú°û°Ðü°ý°þ°ìHˈXêE>´ú
×=ö›?¼–¤ÒÜÉÕ©âX ÎXÖWüüë$! Construct from a trie and valuesÁË # SafetyÁü­OL The actual values contained in the trie must be valid indices into `values`Áô•ïÉ ×}ÖW
XO>c>üÈ6ÕïË ÍÿËÖWü‚3ÕïË ÿËÖW5ü¼¿óô óÖW¨¨£@ªÉ@«â@¼ñ'";LÒµôø°ú°û°Ðü°ý°þ°ìHˈXêE>Ïg Ì
X×=Û›?¼ÿæ<closure_kind>Á<closure_signature>Á<upvars>ÁX£Õ}ô¼ÕïË Áÿ˯Xü…¤üá2/ Construct from a trie and references to valuesÁ˜ËæËü±OûËä™ïÉ 
Ø}¯X
X?*?üÓ 9ÕïË Ø ÿ˯Xü!6ÕïË •!ÿËT˜!¯X 5 üÍ!Ð!õö õ¯X¨¨£@ªÉ@«â@¼ñ'";LÒµö…Ð Ý!
X$Þ!×=ì!"÷# ˜Ð!°Ð!ÍÐ!! !XöÑ £ üÑ((ü¸'HE Optimized data stored as a single VarZeroSlice to reduce token countÁtÜ(Õ##ïË ë(ÿËTî(áØ}l“)
Ø}¹üµ)B„Y°<*ÚêU$%HJüÔ*($Ô*""ïÉü‚+N4+"" è€üÕ+¿Õ''ïË Ú+ÿËTÝ+‚Øl¯,‘ØüÑ,B„Y "üš-¤Õ))ïË Ÿ-ÿËT¢-‚ØlÙ-‘Øüû-B„Y*"$üÛ/ËüÅ.$¯Ëî.Ëdö.æËü‡/OûËôï/ïÉûØ„Y((
*Xà?p@üÐ1¼Õ,,ïË Õ1ÿËTØ1‚Øl§2‘ØüÉ2B„Y-5-(*ü“33÷ø ÷„Y¨¨£@ªÉ@«â@¼ñ'";LÒµø…Ð+ £3+
-X$¤3×=²3?¼Ö3½5-˜Ð.°Ð.ÍÐ..-.XöÑ ¹æ€üÄA !
øûü«3 üˆ"  A backing store for baked dataÁ 3Õ434ªâü«â 7øÞ ©â°[ ¿ °[ 3ðÞG„ß<ðÞS„ßH555ACü…ƒ Üå  Get the value for a keyÁˆ ùú ùøÞ¨¨£@ªÉ@«â@¼ñ'";LÒµúø°ú°û°Ðü°ý°þ°ìHˈXêE>ßßàß âì Ô«|oPŸ¥°[3  3
5øÞ°[$– reqÁ¤ ?¼É ´ 7„¬ 77ðÞœ¬ 7ðÞðÞ\±%üË:7 Traits for data providers that produce opaque buffers.Á¹%«®×2°Ì89ò‘4¯ã89ó¡.®89ôÚ½­n89÷¬
´89úϸƒ.«89ûÔß ªß89þþß Äà89þþ£ªR89ÿÈ+©é89ÿݨY89Ú-Œê789Ö¢Â`89ˆìÁg89ÙÀ¨89ˆ±Š¿
89Õ¾89ŠÃ½89ñBŽÏ89õñB¤Ð89õ£@ލ89ö·<ë89ø¯‰:ŒÌ89ù°ÿAÁ89üЖHŠ¡89ýÕ¼=û89Ñø>ˆ89ÒžCÓ89ƒtüò'ÍY;| ::™Êüý;üÄ.+ A data provider that returns opaque bytes.ÁóËü÷YV Generally, these bytes are expected to be deserializable with Serde. To get an objectÁüÑHE implementing [`DataProvider`] via Serde, use [`as_deserializing()`].ÁšËüž[X Passing a `BufferProvider` to a `*_with_buffer_provider` constructor requires enablingÁüúA> the deserialization Cargo feature for the expected format(s):Áļ - `deserialize_json`ÁôÕ - `deserialize_postcard_1`Áìô - `deserialize_bincode_1`Á Ëü– ZW Along with [`DataProvider`], this is one of the two foundational traits in this crate.Áñ Ëüõ LI [`BufferProvider`] can be made into a trait object. It is used over FFI.ÁÂ
Ë
 # ExamplesÁÕ
Ë
Úüá
,) # #[cfg(feature = "deserialize_json")] {ÁüŽ  use icu_locale_core::langid;Áü¯ %" use icu_provider::hello_world::*;ÁüÕ !êÌ÷  use std::borrow::Cow;Á Ëü• B? let buffer_provider = HelloWorldProvider.into_json_provider();ÁØ ËìÜ  // Deserializing manuallyÁ  assert_eq!(ÁüŠ
-* serde_json::from_slice::<HelloWorld>(Áܸ
 buffer_providerÁÜÔ
 .load_data(Áüð
'$ HelloWorldV1::INFO,Áü˜! DataRequest {Áüº?< id: DataIdentifierBorrowed::for_locale(Áüú1. &langid!("de").into()ÁÔ¬ ),ÁüÇ,) ..Default::default()Á¬ôŒŠüœ.+ .expect("load should succeed")ÁÄË .payloadÁ´ä .get()Áü…&# .expect("should deserialize"),Á¤¬ HelloWorld {ÁüÁ1. message: Cow::Borrowed("Hallo Welt"),Á },Á );ÁËü‰  // Deserialize automaticallyÁüªA> let deserializing_provider: &dyn DataProvider<HelloWorldV1> =Áüì,) &buffer_provider.as_deserializing();ÁË|µñô­ deserializing_providerÁüÌ .load(DataRequest {ÁüìNK id: DataIdentifierBorrowed::for_locale(&langid!("de").into()),Áü»$! ..Default::default()Á })Áüï*' .expect("load should succeed")Á¤š .payloadÁœ¯ .get(),Á¬Ã &HelloWorld {ÁüÙ1ƒ÷T‹¼÷4–Î÷< # }ÁÚ­Ëü±KH [`as_deserializing()`]: AsDeserializingBufferProvider::as_deserializingÁt‡<<ðÞüý>`øÞÍYü—!<ðÞ+ÐþðÞ7Ðþ*ü½HÛ>>ªâZ Â`‚ZÍYüÅ!‚ZŒëZ@üÁ6üƒ96 Returns an error if the buffer format is not enabled.Á|Èû ûZê³í³î³Òï³ìð³ñ³ò³ìäs{©¶è^? Ø?
@¤¾%üË>
; 📚 *This module documents ICU4X constructor signatures.*ÁŠ
ËüŽ`
] One of the key differences between ICU4X and its parent projects, ICU4C and ICU4J, is in howÁôï
 it deals with locale data.ÁŽ
Ëü’V
S In ICU4X, data can always be explicitly passed to any function that requires data.ÁüéC
@ This enables ICU4X to achieve the following value propositions:Á­
Ëü±Z
W 1. Configurable data sources (machine-readable data file, baked into code, JSON, etc).ÁüŒ=
: 2. Dynamic data loading at runtime (load data on demand).ÁüÊS
P 3. Reduced overhead and code size (data is resolved locally at each call site).ÁüžB
? 4. Explicit support for multiple ICU4X instances sharing data.Áá
ËüåW
T However, as manual data management can be tedious, ICU4X also has a `compiled_data`Áü½Q
N default Cargo feature that includes data and makes ICU4X work out-of-the box.Á
Ëü“Q
N Subsequently, there are 3 versions of all Rust ICU4X functions that use data:Áå
Ë
 1. `*`Áœô
 2. `*_unstable`Áüˆ 
 3. `*_with_buffer_provider`Á¨
Ëü¬ %
" # Which constructor should I use?ÁÒ
Ë´Ö
 ## When to use `*`Áí
Ëüñ [
X If you don't want to customize data at runtime (i.e. if you don't care about code size,ÁüÍ
c
` updating your data, etc.) you can use the `compiled_data` Cargo feature and don't have to thinkÁü± %
" about where your data comes from.Á×
ËüÛ c
` These constructors are sometimes `const` functions, this way Rust can most effectively optimizeÁÄ¿
 your usage of ICU4X.ÁØ
蟆 
 ## When to use `*_unstable`Áü
Ëü€
\
Y Use this constructor if your data provider implements the [`DataProvider`] trait for allÁüÝ
B
? data structs in *current and future* ICU4X versions. Examples:Á 
Ëü¤I
F 1. `BakedDataProvider` generated for the specific ICU4X minor versionÁüî6
3 2. Anything with a _blanket_ [`DataProvider`] implÁ¥
Ëü©]
Z Since the exact set of bounds may change at any time, including in minor SemVer releases,Áü‡R
O it is the client's responsibility to guarantee that the requirement is upheld.ÁÚ
ËüÞ+
( ## When to use `*_with_buffer_provider`ÁŠ
ËüŽ^
[ Use this constructor if your data originates as byte buffers that need to be deserialized.ÁüíE
B All such providers should implement [`BufferProvider`]. Examples:Á³
ËÜ·
 1. [`BlobDataProvider`]ÁÌÓ
 2. [`FsDataProvider`]ÁüíU
R 3. [`ForkByMarkerProvider`] between two providers implementing [`BufferProvider`]ÁÃ
蟂a
^ Please note that you must enable the `serde` Cargo feature on each crate in which you use theÁü©)
& `*_with_buffer_provider` constructor.ÁÓ
Ëä×
 # Data Versioning PolicyÁô
ËüøF
C The `*_with_buffer_provider` functions will succeed to compile andÁü¿\
Y run if given a data provider supporting all of the markers required for the object beingÁüœa
^ constructed, either the current or any previous version within the same SemVer major release.Áüþ_
\ For example, if a data file is built to support FooFormatter version 1.1, then FooFormatterÁüÞc
` version 1.2 will be able to read the same data file. Likewise, backwards-compatible markers canÁüÂR
O always be included by `icu_provider_export` to support older library versions.Á
蟪i
f The `*_unstable` functions are only guaranteed to work on data built for the exact same minor versionÁüƒb
_ of ICU4X. The advantage of the `*_unstable` functions is that they result in the smallest codeÁüæa
^ size and allow for automatic data slicing when `BakedDataProvider` is used. However, the typeÁüÈ]
Z bounds of this function may change over time, breaking SemVer guarantees. These functionsÁü¦`
] should therefore only be used when you have full control over your data lifecycle at compileÁL‡
 time.Á
Ëì•
 # Data Providers Over FFIÁ³
Ëü·_
\ Over FFI, there is only one data provider type: [`ICU4XDataProvider`]. Internally, it is anÁü—L
I `enum` between`dyn `[`BufferProvider`] and a unit compiled data variant.Áä
Ëüèb
_ To control for code size, there are two Cargo features, `compiled_data` and `buffer_provider`,ÁüË4
1 that enable the corresponding items in the enum.Á
Ëü„ A
> In Rust ICU4X, a similar enum approach was not taken because:ÁÆ
ËüÊ C
@ 1. Feature-gating the enum branches gets complex across crates.ÁüŽ![
X 2. Without feature gating, users need to carry Serde code even if they're not using it,Áüê!=
: violating one of the core value propositions of ICU4X.矬"^
[ 3. We could reduce the number of constructors from 4 to 2 but not to 1, so the educationalÁÔ‡#
 benefit is limited.Á¢#
Ëü¦#)
& [`DataProvider`]: crate::DataProviderÁüÐ#2
/ [`BufferProvider`]: crate::buf::BufferProviderÁüƒ$R
O [`FixedProvider`]: ../../icu_provider_adapters/fixed/struct.FixedProvider.htmlÁüÖ$_
\ [`ForkByMarkerProvider`]: ../../icu_provider_adapters/fork/struct.ForkByMarkerProvider.htmlÁü¶%N
K [`BlobDataProvider`]: ../../icu_provider_blob/struct.BlobDataProvider.htmlÁü…&R
O [`StaticDataProvider`]: ../../icu_provider_blob/struct.StaticDataProvider.html矯&J
G [`FsDataProvider`]: ../../icu_provider_blob/struct.FsDataProvider.html矣'T
Q [`ICU4XDataProvider`]: ../../icu_capi/provider/ffi/struct.ICU4XDataProvider.htmlÁdÆ%ü¡(%
¡û'
 þ'
…(
8°4ÿ'
tù'
&|(
BO Ç(
¾.
 Í(
à(
8BUFFERÁ4Î(
$ Ô(
, Ö(
8‡®$×(
& Û(
8ª $Ü(
*â(
 å(
“+
8ï4ï(
 õ(
 ö(
+
7A version of [`ÁŒ„)
$ •)
8µL—)
  )
 ¡)
§)
, ¢)
8‡®$£)
$ ¨)
7`] that uses custom data 熻)
$ Å)
7%provided by a [`BufferProvider`].\n\nÁüÓ)'
$ ú)
7+✨ *Enabled with the `serde` feature.*\n\nÁüˆ*-
$ µ*
7>[📚 Help choosing a constructor](icu_provider::constructors)ÁüÃ*@
$ ƒ+
% ”+
 š+
¯+
8UNSTABLEÁD+
$ £+
, ¥+
8‡®$¦+
& ª+
8ª $«+
*±+
 ´+
».
8ï4¾+
 Ä+
 Å+
µ.
7 ®ŒÓ+
$ ä+
8µLæ+
 ï+
 ð+
ö+
, ñ+
8‡®$ò+
$ ÷+
7û®Üù+
$ ”,
7#provided by a [`DataProvider`].\n\n矢,%
$ Ç,
7B[📚 Help choosing a constructor](icu_provider::constructors)\n\nÁüÕ,D
$ ™-
7ƒ<div class=\"stab unstable\">âš ï¸ The bounds on <tt>provider</tt> may change over time, including in SemVer minor releases.</div>Áü§-…
% ¼.
üì4)
TÁ.
 Usage:ÁÌ.
Ë”Ð.
 ```rust,ignoreÁüã.T
Q gen_buffer_data_constructors!((locale, options: FooOptions) -> error: DataError,Á¤¸/
 /// Some docsÁüÍ/J
G functions: [try_new, try_new_with_buffer_provider, try_new_unstable]Á4˜0
Î÷<Ÿ0
Ú§0
Ëü«0
Š `functions` can be omitted if using standard names. If `locale` is omitted, the method will not take a locale. You can specify any numberÁü¹1)
& of options arguments, including zero.Áã1
Ëüç1a
^ By default the macro will generate a `try_new`. If you wish to skip it, write `try_new: skip`ÁÉ2
ËüÍ2ˆ
 Errors can be specified as `error: SomeError` or `result: SomeType`, where `error` will get it wrapped in `Result<Self, SomeError>`.Á¡Æ4
 É4
Ð4
8°4Ê4
tÄ4
&|Ü4
QV 5
P
 Æ5
Š6
 Ç5
Ô5
, È5
 É5
Ò5
, Ê5
8þ$Ë5
& Ï5
8Ð5

Ó5
(Ö5
, Ù5
8
error_kindÁTÚ5
& ä5
8Û,å5
& ê5
, ì5
8error_tyÁDí5
& õ5
8ö5
$ ø5
, ú5
 û5
ˆ6
+ ü5
 ý5
‡6
, þ5
8¡ÿ5
& 6
8«
$ƒ6

‰6
*Œ6
 6
À8
, ™6
8,š6
'Ÿ6
8¯ä¡6
 ½6
 ¾6
¹8
 Ì6
Ö6
, Í6
 Î6
Ô6
, Ï6
8þ$Ð6

Õ6
(Ø6
, Û6
8§¼TÜ6
& æ6
, è6
8ܼDé6
$ ñ6
, ÿ6
 €7
ˆ7
+ 7
 7
‡7
, ƒ7
8¡„7

‰7
8 functionsÁL—7
&  7
 ¢7
¯8
8try_newÁ<´7
$ »7
8try_new_with_buffer_providerÁäÍ7
$ é7
8try_new_unstableÁ„û7
$ 8
8$8
$ ¡8
% º8
% Á8
 €9
¤:
 9
Ž9
, 9
 ƒ9
Œ9
, „9
8þ$…9
& ‰9
8Š9

9
(9
8,“9
& ˜9
, š9
8ܼD9
& £9
8ª $¤9
$ ¨9
, ª9
 «9
¸9
+ ¬9
 ­9
·9
, ®9
8¡¯9
& ²9
8«
$³9

¹9
8Ü¿L»9
& Ä9
 Æ9
£:
, Ç9
8ø,È9
& Í9
8Û,Î9
, Ó9
 Ô9
ç9
& Õ9
, ×9
8 baked_cmdÁLØ9
& á9
8Û,â9
- è9
$ é9
, ë9
8bufferÁ4ì9
& ò9
8Û,ó9
$ ø9
, ú9
8÷Dû9
& ƒ:
8Û,„:
, Š:
 :
:
$ Œ:
, Ž:
84:
& •:
8Û,:
- œ:
, ž:
 Ÿ:
¡:
$  :
- ¢:
*¦:
 ©:
Ý<
, ³:
8,´:
'¹:
8¯ä»:
 ×:
 Ø:
Ö<
 æ:
ð:
, ç:
 è:
î:
, é:
8þ$ê:

ï:
(ò:
8Û
4õ:
& û:
8ý4ý:
 ƒ;
8$„;
$ ˆ;
, Š;
8ܼD;
 “;
$ ”;
, ¢;
 £;
«;
+ ¤;
 ¥;
ª;
, ¦;
8¡§;

¬;
8Ü¿Lº;
& Ã;
 Å;
Ì<
, ×;
8ø,Ø;
, Ý;
 Þ;
ë;
& ß;
, á;
8ãÃLâ;
- ì;
$ í;
, ÿ;
8žÄ4€<
$ †<
, ˜<
8÷D™<
, ²<
 ³<
½<
$ ´<
, ¶<
84·<
- ¾<
% ×<
% Þ<
 ý<
©>
 þ<
“=
8â@4ÿ<
$ …=
, ‡=
 ˆ=
=
, ‰=
8þ$Š=
& Ž=
8=

=
(•=
8Û
4˜=
& ž=
,  =
8 result_tyÁL¡=
& ª=
8«=
$ ­=
, ¯=
 °=
½=
+ ±=
 ²=
¼=
, ³=
8¡´=
& ·=
8«
$¸=

¾=
8Ü¿LÀ=
& É=
 Ë=
¨>
, Ì=
8ø,Í=
& Ò=
8Û,Ó=
, Ø=
 Ù=
ì=
& Ú=
, Ü=
8ãÃLÝ=
& æ=
8Û,ç=
- í=
$ î=
, ð=
8žÄ4ñ=
& ÷=
8Û,ø=
$ ý=
, ÿ=
8÷D€>
& ˆ>
8Û,‰>
, >
 >
 >
$ >
, “>
84”>
& š>
8Û,>
- ¡>
, £>
 ¤>
¦>
$ ¥>
- §>
*«>
 ®>
ò@
, ¸>
8,¹>
'¾>
8¯äÀ>
 Ü>
 Ý>
ë@

 ë>
?
 8â@4ì>
& ò>
 ô>
, õ>
8,ö>
'û>
8Tý>
$ ‡?
, ‰?
 Š?
?
, ?
8þ$Œ?

?
(”?
8Û
4—?
& ?
, Ÿ?
8ÜÊL ?
$ ©?
, ·?
 ¸?
À?
+ ¹?
 º?
¿?
, »?
8¡¼?

Á?
8Ü¿LÏ?
& Ø?
 Ú?
á@
, ì?
8ø,í?
, ò?
 ó?
€@
& ô?
, ö?
8ãÃL÷?
- @
$ @
, ”@
8žÄ4•@
$ @
, ­@
8÷D®@
, Ç@
 È@
Ò@
$ É@
, Ë@
84Ì@
- Ó@
% ì@
% ó@
 ù@
—B
 ú@
A
8â@4û@
(ƒA
8Û
4†A
& ŒA
, ŽA
8ÜÊLA
& ˜A
8™A
$ A
, A
 žA
«A
+ ŸA
  A
ªA
, ¡A
8¡¢A
& ¥A
8«
$¦A

¬A
8Ü¿L®A
& ·A
 ¹A
B
, ºA
8ø,»A
& ÀA
8Û,ÁA
, ÆA
 ÇA
ÚA
& ÈA
, ÊA
8ãÃLËA
& ÔA
8Û,ÕA
- ÛA
$ ÜA
, ÞA
8žÄ4ßA
& åA
8Û,æA
$ ëA
, íA
8÷DîA
& öA
8Û,÷A
, ýA
 þA
ŽB
$ ÿA
, B
84B
& ˆB
8Û,‰B
- B
, B
 B
”B
$ “B
- •B
*™B
 œB
ÕD
, ¦B
8,§B
'¬B
8¯ä®B
 ÊB
 ËB
ÎD

 ÙB
õB
8â@4ÚB
& àB
 âB
, ãB
8,äB
'éB
8TëB
(÷B
8Û
4úB
& €C
, C
8ÜÊLƒC
$ ŒC
, šC
 C
£C
+ œC
 C
¢C
, žC
8¡ŸC

¤C
8Ü¿L²C
& »C
 ½C
ÄD
, ÏC
8ø,ÐC
, ÕC
 ÖC
ãC
& ×C
, ÙC
8ãÃLÚC
- äC
$ åC
, ÷C
8žÄ4øC
$ þC
, D
8÷DD
, ªD
 «D
µD
$ ¬D
, ®D
84¯D
- ¶D
% ÏD
% ÖD
 ÞD
‡F
 ßD
‡E
, àD
 áD
„E
 , âD
8 options_argÁ\ãD
& îD
8Û,ïD
& ôD
, öD
8
options_tyÁT÷D
& E
8E
$ …E

†E
(‰E
8Û
4ŒE
& E
, ”E
8ÜÊL•E
& žE
8ŸE
$ ¡E
, £E
 ¤E
±E
+ ¥E
 ¦E
°E
, §E
8¡¨E
& «E
8«
$¬E

²E
8Ü¿L´E
& ½E
 ¿E
†F
, ÀE
8ø,ÁE
& ÆE
8Û,ÇE
$ ÌE
, ÎE
8žÄ4ÏE
& ÕE
8Û,ÖE
$ ÛE
, ÝE
8÷DÞE
& æE
8Û,çE
, íE
 îE
þE
$ ïE
, ñE
84òE
& øE
8Û,ùE
- ÿE
, F
 F
„F
$ ƒF
- …F
*‰F
 ŒF
ÆK
+ F
 —F
¶F
8¢˜F
 F
µF
8<œF
¤F
7
compiled_dataÁ|¦F
, ÀF
 ÁF
ÉF
+ ÂF
 ÃF
ÈF
, ÄF
8¡ÅF

ÊF
<ËÔF
<6 ✨ *Enabled with the `compiled_data` Cargo feature.*ÁüàF9
<Ë¢G
<? [📚 Help choosing a constructor](icu_provider::constructors)Áü®GB
8ùG
8 ýG
, €H
8ø,H
 †H
¦H
, ‡H
 ˆH
¢H
, ‰H
8ÜÚ\ŠH
& •H
, —H
8’ÛT˜H
$ £H

¤H
(¨H
, «H
8ÜÊL¬H
 ¶H
“I
, ÄH
 ÅH
ÑH
, ÆH
84ÇH
'ÎH
- ÒH
, ÔH
8÷DÕH
 ÝH
‰I
  ÞH
8,ßH
'äH
8providerÁDæH
'îH
8BakedÁ,ðH
, öH
 ÷H
†I
$ øH
, úH
8ÜÚ\ûH

‡I
, žI
8,ŸI
'¤I
8¯ä¦I
 ÂI
 ÃI
¿K

 ÑI
ðI
, ÒI
 ÓI
íI
, ÔI
8ÜÚ\ÕI
& àI
, âI
8’ÛTãI
$ îI

ïI
(òI
8Û
4õI
& ûI
, ýI
8ÜÊLþI
$ ‡J
, •J
 J
žJ
+ —J
 ˜J
J
, ™J
8¡šJ

ŸJ
8Ü¿L­J
& ¶J
 ¸J
µK

, ÊJ
8ø,ËJ
& ÐJ
8í$ÒJ
$ ÖJ
, èJ
8žÄ4éJ
$ ïJ
, K
8÷DK
, K
 œK
¦K
$ K
, ŸK
84 K
- §K
% ÀK
% ÇK
 ÍK
üL
 ÎK
öK
, ÏK
 ÐK
óK
 , ÑK
8ÜÚ\ÒK
& ÝK
8Û,ÞK
& ãK
, åK
8’ÛTæK
& ðK
8ñK
$ ôK

õK
(øK
8Û
4ûK
& L
, ƒL
8ÜÊL„L
& L
8ŽL
$ L
, L
 “L
 L
+ ”L
 •L
ŸL
, L
8¡—L
& šL
8«
$L

¡L
8Ü¿L£L
& ¬L
 ®L
ûL
, ¯L
8ø,°L
& µL
8Û,¶L
& »L
8í$½L
$ ÁL
, ÃL
8žÄ4ÄL
& ÊL
8Û,ËL
$ ÐL
, ÒL
8÷DÓL
& ÛL
8Û,ÜL
, âL
 ãL
óL
$ äL
, æL
84çL
& íL
8Û,îL
- ôL
, öL
 ÷L
ùL
$ øL
- úL
*þL
 M
šP

+ M
 ŒM
£M
8¢M
 M
¢M
8<M
™M
7à<M
+ ­M
 ®M
õM
8¡¯M
³M
, µM
8,¶M
'»M
8ĽM
 ÕM
 ÖM
ôM
8¯­4×M
$ ÝM
, ßM
 àM
ëM
, áM
84âM
'éM
- ìM
, îM
8ø,ïM
8ÿM
8 ƒN
, †N
8žÄ4‡N
 N
åN
8ÇãDŽN
& N
 ˜N
 ™N
ÃN

8$šN
, ŸN
8, N
'¥N
8٤N
'ªN
8Ât¬N
»N
- ½N
8Œ,¾N
, ÅN
 ÆN
âN
$ ÇN
, ÉN
8ÜÚ\ÊN
& ÕN
, ×N
8’ÛTØN

ãN
(çN
, êN
8ÜÊLëN
 õN
”P
8#ƒO
, ‡O
8,ˆO
'O
8ŸO
'O
8ì”O
% ±O
, ¿O
 ÀO
ÌO
, ÁO
84ÂO
'ÉO
- ÍO
, ÏO
8÷DÐO
 ØO
ŠP
 ÙO
8ÇãDÚO
 âO
8as_deserializingÁ„ãO
 óO
ôO
, ÷O
 øO
‡P
$ ùO
, ûO
8ÜÚ\üO

ˆP
% P
|Ô%üË9 6 Utilities for using trait objects with `DataPayload`.Á<Ü%Eimpl_casting_upcastÁœ„ HIimpl_dynamic_data_providerÁÔª0 JK#impl_iterable_dynamic_data_providerÁüô7# LMô± ü†H E Trait to allow conversion from `DataPayload<T>` to `DataPayload<S>`.ÁÏ ËüÓ] Z This trait can be manually implemented in order to enable [`impl_dynamic_data_provider`].ÁŒ» EÕFEFðÞü± “ß Í °[ÄÝ ©âøÞ, øÞĉ EðÞQÏ÷-à÷#ðÞcÏ÷?à÷5GGGnpüD ü©S P Upcast a `DataPayload<T>` to a `DataPayload<S>` where `T` implements trait `S`.Á4„ Çáßßàß âì Ô«|oPŸ¥øÞEE
GøÞ°[î ,‹ üð " üÉV S Implements [`UpcastDataPayload`] from several data markers to a single data markerÁü > ; that all share the same [`DynamicDataMarker::DataStruct`].Áß Ë Èîò Ë Úüþ! êÌ  Žðº ËŒ¾  struct FooV1;ÁüÐ& # impl DynamicDataMarker for FooV1 {Áü÷' $ type DataStruct = Foo<'static>;Á ü¥4 1 icu_provider::data_marker!(BarV1, Foo<'static>);ÁüÚ4 1 icu_provider::data_marker!(BazV1, Foo<'static>);Á Ëì“  #[derive(yoke::Yokeable)]Áܱ  pub struct Foo<'data> {ÁüÍ !  message: Cow<'data, str>,Á  };Áö Ëüú ( % icu_provider::data_struct!(Foo<'_>);Á£
Ëü§
H E icu_provider::dynutil::impl_casting_upcast!(FooV1, [BarV1, BazV1,]);Á
Úø
Ëüü
K H [`DynamicDataMarker::DataStruct`]: crate::DynamicDataMarker::DataStructÁ¡Ú  Ý ä 8°  &|È Ôx Ò  À , š 8dyn_mÁ, &   8ª $ ¥  § ¿ , ©  ª º , « 8struct_mÁ & ´ 8Û $ »  ¼ $ ½ *  Å Ð , Ï  Ð É 8 , ã 8 'é 8Ò 'ò 8àŒô 
,
8·D‡

8

,
8æ€,
 œ
¿ 
8 ®
8ÿ
 ·
Ý

8î ,¸
& ½
, ¿
8
'Å
8ß
 Ò
, Ó
8·
 Ü
(ß
, â
8
'è
8ß
 õ
, ö
8æ€
 ü
 þ
± 8î ,”   8ö(  ž Ÿ  Ê ¬ë ÔüÇ) üš^ [ Implements [`DynamicDataProvider`] for a marker type `S` on a type that already implementsÁüùa ^ [`DynamicDataProvider`] or [`DataProvider`] for one or more `M`, where `M` is a concrete typeÁüÛ9 6 that is convertible to `S` via [`UpcastDataPayload`].Á Ëä™  ## Wrapping DataProviderÁ Ëüº\ Y If your type implements [`DataProvider`], pass a list of markers as the second argument.Áü—] Z This results in a `DynamicDataProvider` that delegates to a specific marker if the markerÁüõ> ; matches or else returns [`DataErrorKind::MarkerNotFound`].Á´ Ëü¸7 4 [`DynamicDataProvider`]: crate::DynamicDataProviderÁüð) ЧüšM J [`DataErrorKind::MarkerNotFound`]: (crate::DataErrorKind::MarkerNotFound)Áüè6 3 [`SerializeMarker`]: (crate::buf::SerializeMarker)Á¡¡  ¤ « 8°  &|· ª~ ñ ñ/   ¸ ë , ¹ 8Çã &  8à $ Å , Ç 8armsÁ & Ì 8Í $ Ï , Ñ 8oneÁÒ & Õ 8ª  $ Ú , Ü  Ý è , Þ 8restÁ & ã 8ª  $ é  ê *í  ð õ , ú 8 ' 8Ò< ' 8àóÔ‹  ¥  ¦ ë , ´ 8Çã $ ½ , Ë 8÷Œ $ Ð , Þ 8¦ß % ì , ÷ 8 'ý 8Ò<ÿ ' 8àóÔˆ  ¢  £ î 
, ± 8Çã $ º , È 8÷Œ $ Í , Û  Ü â , Ý 8è $ ã  ä % ï % ö  ý â  , þ 8ÇãDÿ &  8ˆ $ Š  Œ Ö , Ž   » ,  8Û, &  8Û,—  , Ÿ 8
4  & ¦ 8ª  *¬ , ¯ 8· & ¸ 8¹ $ ¼  ½ $ ¾ , À  Á Ô 8  *Ä , Ç 8struct_dÁ & Ð 8Ñ $ Ó - Õ $ × , Ù 8æ€ & ß 8à *ä  ç À& 
8 , ö 8 'ü 8¢œþ   ,  8æ€,“  ˜ 8
š , ž 8Çã  ° ¹& 8 ¾ 8Ã  Ê É  Ü 8 $ á 8
 & ù , û 8 ' 8H $  8 á£ & ¦ , ¨ 8 '® 8¼= $ » (Ë 8ý  Ô , æ 8 'ì 8È+  ú , û 8æ€   $  ,  8,• 'š 8·< $ ¥  ³  µ ¯& 8 8
  Ó 8×=Ô  Ö 8ê1  Ý Þ  à ¡&  , ö  ÷ —! 
8  8 8Á˜  ˜ ,  8
  ¢ 8×=£  ¥ 8ê1  ¬ ­ *¯  ² ! 8Ð 8Û
 & Ú , Ü 8 'â 8È+  ð , ñ 8·  ú ü , ž 8 '¤ 8¢œ¦ '¹  » , ¼ 8·  Å 'Æ 8à  Ñ ã 8 $ Ö 8
 $ Þ 8 áà - ä % å 8Òƒ   ç ,  8,‡ 'Œ 8È+   æ 8ä+ & Å 8Û
  Í 8ä+ $ Ö 8ô+ & ÿ , 8, ' 8Ò<‰ ' 8àŒ’ '£  ¥ , ¦ 8·  ¯ '° 8ÿ  ¸ Ç 8Û
 ¿ 8ô+ $ È ˜! $ ™! , ¯!  °! ´% 8 Ê! *Ì!  Ï! ž% 8í! 8Û
4ñ! & ÷! , ù! 8,ú! 'ÿ! 8È+d"  " , Ž" 8š“D"  —" ™" , »" 8,¼" 'Á" 8¢œÃ" 'Ö"  Ø" , Ù" 8š“DÚ"  â" 'ã" 8ÃLå"  î" €# 8$ï" $ ó" 8
4õ" $ û" 8 áý" - # % # 8Ò #  ¢# „% , £# 8,¤# '©# 8È+d«#  ¸# ƒ% 8ä+DÚ# & â# 8Û
4ä#  ê# 8ä+Dë# $ ó# 8ô+<•$ & œ$ , ž$ 8,Ÿ$ '¤$ 8Ò<¦$ '­$ 8àŒ¯$ 'À$  Â$ , Ã$ 8š“DÄ$  Ì$ 'Í$ 8ÿ4Ï$  Õ$ ä$ 8Û
4Ö$  Ü$ 8ô+<Ý$ $ å$ - µ% 8 Ë% *Í% 8Ð%  Ó% &  , Ô% 8,Õ% 'Ú% 8‰:lÜ% 'é% 8õ:të%  ù% 8ªDú%  & Ž& 8
4ƒ& $ ‰& 8 á& % Á&  Ç& Š'  , È& 8ÇãDÉ& & Ñ& 8Ò& $ Ô&  Ö& ü& , Ø&  Ù& ÷& , Ú&  Û& è& + Ü&  Ý& ç& , Þ& 8¢ß& & â& 8«
$ã& - é& , ë& 8·Dì& & ô& 8õ& $ ø&  ù& $ ú& $ ý& , ÿ& 8æ€,€' & …' 8ª $†' *Œ'  ' î/ 
8$™' , ž' 8,Ÿ' '¤' 8¢œ¦'  ¹' , º' 8æ€,»'  À' 8
Â' , Æ' 8ÇãDÇ'  Ø' è/ 8 æ' 8ÃLé'  ò' ñ(  „( 8$…( $ ‰( 8
4( & ¡( , £( 8,¤( '©( 8Ht«( $ ¹( 8 áË( & Î( , Ð( 8,Ñ( 'Ö( 8¼=\Ø( $ ã( (ó( 8ý4ö(  ü( , Ž) 8,) '”) 8È+d)  ¢) , £) 8æ€,¤)  ©) $ ª) , ¼) 8,½) 'Â) 8·<LÄ) $ Í)  Û)  Ý) Þ/ 8,ï) 8
4õ)  û) 8×=ü)  þ) 8ê14ÿ)  …* †*  ˆ* Ð/ , ž*  Ÿ* â. , ¹*  º* Â* + »*  ¼* Á* , ½* 8¢¾* - Ã* 8Á˜ Ý* 8ß* 8Á˜ â* ä*  ç* , è* 8·Dé* 8ò* , õ* 8,ö* 'û* 8ƒ.Tý*  ‡+ 'ˆ+ 8•.$Š+  Ž+ 8×=+  + 8ê14+  ˜+ ™+ *+  ž+ Ì. 8¼+ 8Û
4À+ & Æ+ , È+ 8,É+ 'Î+ 8È+dÐ+  Ü+ , Ý+ 8·DÞ+  æ+ è+ , Š, 8,, ', 8£d, 'ž, 8Ù $ ,  ¤, ®, 8$¥, $ ©, 8 á«, - ¯, % °, 8ÒÎ,  Ð, ². , Ñ, 8,Ò, '×, 8È+dÙ,  æ, ±. 8ä+Dˆ- & - 8Û
4-  ˜- 8ä+D™- $ ¡- 8ô+<Ã- & Ê- , Ì- 8,Í- 'Ò- 8Ò<Ô- 'Û- 8àŒÝ- 'î-  ð- , ñ- 8·Dò-  ú- 'û- 8ÿ4ý-  ƒ. . 8Û
4„.  Š. 8ô+<. $ “. ã. $ ä. 8 ú. *ü. 8ÿ.  / ¾/  , ƒ/ 8,„/ '‰/ 8‰:l/ '˜/ 8õ:tš/  ¨/ 8ªD©/  ±/ ½/ 8
4²/ $ ¸/ 8 áº/ % ï/ äŠ0 Iüï02 ¡É0  Ì0 Ó0 8°4Í0 tÇ0 &|ß0 ‹‡ ¢1 ²7  ¨1 ë1  , ©1 8ÇãDª1 & ²1 8³1 $ µ1  ·1 Ý1 , ¹1  º1 Ø1 , »1  ¼1 É1 + ½1  ¾1 È1 , ¿1 8¢À1 & Ã1 8«
$Ä1 - Ê1 , Ì1 8·DÍ1 & Õ1 8Ö1 $ Ù1  Ú1 $ Û1 $ Þ1 , à1 8æ€,á1 & æ1 8ª $ç1 *í1  ð1 °7 
8$ú1 , ÿ1 8,€2 '…2 8µ܇2  ¢2 , £2 8æ€,¤2  ©2 8
«2 , ¯2 8ÇãD°2  ¹2 ª7 8 Ç2 8iter_ids_for_markerÁœÊ2  Ý2 ƒ3   Þ2 8$ß2 $ ã2 8
4å2 & ë2 , í2 8,î2 'ó2 8Htõ2 (…3 8ý4ˆ3  Ž3 8á,3 '”3 8 collectionsÁ\3 '¡3 8eD£3  «3 , ¬3 8,­3 '²3 8ý
Œ´3  Å3 :8Æ3 È3 $ Ê3 , Ì3 8,Í3 'Ò3 8·<LÔ3  Ý3  ß3  7 8,ñ3 8
4÷3  ý3 8×=þ3  €4 8ê144  ‡4 ˆ4  Š4 7 ,  4  ¡4 ¦6 , »4  ¼4 Ä4 + ½4  ¾4 Ã4 , ¿4 8¢À4 - Å4 8Á˜ ß4 8á4 8Á˜ ä4 æ4  é4 , ê4 8·Dë4 8ô4 , ÷4 8,ø4 'ý4 8ƒ.Tÿ4  ‰5 'Š5 8•.$Œ5  5 8×=5  “5 8ê14”5  š5 5 *5   5 6  , ¾5 8,¿5 'Ä5 8ƒ¤Æ5 'Ú5  Ü5 , Ý5 8·DÞ5  æ5 'ç5 8iter_idsÁDé5  ñ5 ö5 8$ò5  §6 $ ¨6 8 ¾6 *À6 8Ã6  Æ6 €7  , Ç6 8,È6 'Í6 8‰:lÏ6 'Ü6 8õ:tÞ6  ì6 8Þ\í6  ø6 ÿ6 8
4ù6 üË7% Ø$ŒÇ'lË'RY`gnÃÑ‚NOÑ‚ŠNOYokeableÁDôÀNPǾ (NPÕNQŠÂù~<NQð×2ø~ÌNQò4÷~ãNQó¡.ö~NQôÚÛ~
´NQúϸƒ.Ú~NQûÔß Ù~ßNQþþß ó~àNQþþÈ+¿~éNQÿÚ-ýmNQÖÙŠ~¨NQˆ±Š‰~
NQÃr~NQà7q~ªNQïà7‡~«NQïñBq~ÏNQõñB‡~ÐNQõ£@q~¨NQö·<p~ëNQø¯‰:o~ÌNQù°ÿAn~ÁNQüÐHm~¡NQýÕ¼=l~ûNQÑø>k~NQÒžCj~ÓNQƒÌÏÙ±ÌÞü—FC A data provider that loads data for a specific [`DataMarkerInfo`].ÁRÕSRSðÞüÞÍ“ß õ£ßT…RðÞ)ðÞ/TTT.0üâGü—63 Query the provider for data, returning the result.ÁÒËüÚ^[ Returns [`Ok`] if the request successfully loaded data. If data failed to load, returns anÁü½  Error with more information.Á$åüý üøÞûû¼=ý×=þä+ØÎ†Ë¦XÁ&ýê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ééÈ+ëä+ìô+MÕRÕs)°[è^R êR
TøÞ°[ áñü­[8þÕVÛWWVþ“ß ²ªâ©[ µ£ßR©[°[¤[XTX8:57üF$ ÿ ÿ¤[ûû¼=ý×=þä+ØÎ†Ë¦XÁ&™ÉU ¥U
X8°[©[ á¬üÕ9üÁ
XU A data provider that can determine whether it can load a particular data identifier,Áüš:7 potentially cheaper than actually performing the load.ÁYÕZYZðÞüÕñRøÞ°[|ÿ“ß ï£ßYðÞ;ÛÎ-ðÞGÛÎ9[[[:<üôPü•TQ This method goes through the motions of [`load`], but only returns the metadata.ÁîËüöLI If `dry_load` returns an error, [`load`] must return the same error, butÁüÇSP not vice-versa. Concretely, [`load`] could return deserialization or I/O errorsÁüŸ# that `dry_load` cannot predict.ÁÇËüÏ  [`load`]: DataProvider::loadÁD÷ øÞûû¼=ý×=þä+ØÎ†Ë¦XÁ&ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶”fè^Y Y
[øÞ°[$ áüÈa8ƒÕ]Û^]ƒ^“ß Í‹Ë Ð£ßY©[°[¤[_[_0257ü¾O ¤[ûû¼=ý×=þä+ØÎ†Ë¦XÁ&¢Ó\ Ê\
_8°[©[ áÑü! üë=: A data provider that loads data for a specific data type.Á© Ëü­ _\ Unlike [`DataProvider`], there may be multiple markers corresponding to the same data type.Áœ—!`Õaa`ðÞü!—“ß «!À÷Œ»!`ðÞ)ðÞ/bbb.0üŸ#ƒüÔ!6ÜÅ"Ëü—"^¦Æüú" ÇL¢# øÞ™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&™É` µ#`
bøÞ°[$¶#
4Ä# áä#ü¦$p8ˆÕdÛedeˆ“ß «$‹Ë ®$À÷ŒÜ$`©[°[´ö$¤[fbf0257ü«%L®%Š ¤[™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&Š™Éc Á%c
f8°[©[$Â%
4Ð% áð%üÏ0Nü²/a^ A dynanmic data provider that can determine whether it can load a particular data identifier,Áü”0:ïÌ´Ù0gÕhghðÞüÏ0ì`øÞ°[´‡1“ß ð0À÷Œó0gðÞ;ÀÞ-ðÞGÀÞ9iii:<ü­4Œü¤1YV This method goes through the motions of [`load_data`], but only returns the metadata.Á2ËüŠ2VS If `dry_load_data` returns an error, [`load_data`] must return the same error, butÁüå2XU not vice-versa. Concretely, [`load_data`] could return deserialization or I/O errorsÁüÂ3(% that `dry_load_data` cannot predict.Áï3Ëü÷31. [`load_data`]: DynamicDataProvider::load_dataÁl°4Œ øÞ™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&Œ¢Óg Ç4g
iøÞ°[$È4
4Ö4 áö4ü½5v8ÕkÛllk“ß Â5‹Ë Å5À÷Œö5g©[°[Ì6¤[mim0257üÈ6lË6Ž Ž¤[™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&¢Ój â6j
m8°[©[$ã6
4ñ6 á‘7ô×MüáI=ÜÕŸJËü£JVS Unlike [`DataProvider`], the provider is bound to a specific marker ahead of time.ÁúJËüþJc` This crate provides [`DataProviderWithMarker`] which implements this trait on a single providerÁüâKda with a single marker. However, this trait can also be implemented on providers that fork betweenÁüÇL_\ multiple markers that all return the same data type. For example, it can abstract over manyÁü§M/, calendar systems in the datetime formatter.ÁŒáMnÕonoðÞü×MÞ“ß óMÀ÷ŒƒNnðÞ)ðÞ/pqpqpq46üçOMüœN6ÜÅ×NËüßN^¦ÆüÂO ÇTêO øÞûû¼=ý×=þä+ØÎ†Ë¦XÁ&™Én õOn
pøÞ°[$öO áüOüŠQ)ü¹PLI Returns the [`DataMarkerInfo`] that this provider uses for loading data.ÁdQ øÞ™mn šQn
qøÞ°[$›Qü·Ql8ÕsÛtst“ß ¼Q‹Ë ¿QÀ÷ŒëQn©[°[¤…R¤[uvpquv8:=?ü¸RLT»R ¤[ûû¼=ý×=þä+ØÎ†Ë¦XÁ&™Ér ÆRr
u8°[©[$ÇR áÍRü¿S(dÂS ¤[™mr ÏSr
v8°[©[$ÐSü—_XÕxÛyyxïË œ_©â§\ Ÿ_ÿËTÌ_R§\X|ß_í[z24/1üÒ`"üö_WT Creates a [`DataProviderWithMarker`] from a [`DataProvider`] with a [`DataMarker`].Áß`§\í[ww
zX§\Ñ96AüÎaÑÕ|Ä}Í~Û}|~
XÍt¯bó\˜ôtÚb©â˜ô Úa©âí\ ÝaÿËÔ¤bïË Óaó\üÈb!©âó\ÖaÀ˜ô¤òbRí\X|c³\pqjlWY¤¦¡£öbü´cMT·c˜ ³\ûû¼=ý×=þä+ØÎ†Ë¦XÁ&˜ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ééÈ+ëä+ìô+MÕRÕs)ó\è^{ Âc{
Xó\˜ôí\$Ãc áÉcüÑd(dÔd ³\™m{ ád{
Xó\˜ôí\$âdüâ'‘›‡›‡¬‡¬‡½‡½‡χχà‡à‡ñ‡ñ‡LÜ),à)¨ëÌÖ¢ÖŠ²GdïŠÛÍÁ]ŠvŠÂœ<ŠŽð×2œÌŠŽò‘4œãŠŽó¡.œŠŽôÚ½œnŠŽ÷œ
´ŠŽúϸƒ.œŠŽûÔß  œßŠŽþþß àŠŽþþ£RŠŽÿÈ+銎ÿÝYŠŽÚ-€‹ŠŽÖ¢`ŠŽˆìgŠŽŠ
ŠŽÕŠŽŠÃŠŽà7ªŠŽïà7«ŠŽïñBÏŠŽõñBЊŽõ£@¨ŠŽöÿAœÁŠŽüЖHœ¡ŠŽýÕ¼=œûŠŽÑø>œŠŽÒžCœÓŠŽƒCüß)¤ç:,œü¨è^’æ`üÎ8Ñšœ šè^ Á`Á`œÃ`è Á]Ä`ŸÁ]Ê­\É:•œê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ѼѼÒ¼ štÀ. Õ
þ Ü”€€]”ü®*ü™1. Converts this DataErrorKind into a DataError.ÁÏËü×DA If possible, you should attach context using a `with_` function.ÁT»€]è^LJXBü¶Cüð30 Creates a DataError with a data marker context.Á\À]™mè^
âC
ëCüöGüµ.+ Creates a DataError with a string context.Á„ƒ €] è^
÷D­ŠEüÃ!.üÿ 1. Creates a DataError with a type name context.ÁŒÊ!€]è^˜˜©âÖ` Ü!
Ö`$ß!üô"Lü²"/, Creates a DataError with a request context.ÁDû"€]™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&è^\§#
$„#
4Š# á¢#tü#è^›œž ¡£¥üó$6ü‘$OL Returns a new, empty DataError with kind Custom and a string error message.Á4€%Ɔè^šš
Ø<*Fü±'>üÚ&DA Sets the data marker of a DataError, returning a modified error.Á\¾'è^™mè^ššˆUG
^Güþ)Bü¤)GD Sets the string context of a DataError, returning a modified error.Á„‹*è^Ɔè^šš£Š™H­Š£Hüß,)üî+^[ Sets the string context of a DataError to the given type name, returning a modified error.ÁŒæ,è^è^šŸŸšð‡ ø,
žÖ`$û,üá0KüÆ.^[ Logs the data error with the given request, returning an error containing the data marker.Á©/Ëü±/WT If the "logging" Cargo feature is enabled, this logs the whole request. Either way,Áü0OL it returns an error with the data marker portion of the request as context.ÁDè0žè^™mûû¼=ý×=þä+ØÎ†Ë¦XÁ&žè^š\˜1š
 $õ0
4û0 á“1üÓ9Pü¶7A> Logs the data error with the given context, then return self.Áü7Ëü„8RO This does not modify the error, but if the "logging" Cargo feature is enabled,ÁüÛ8" it will print out the context.Á¤Ú9Ÿè^ Ÿè^𢢠˜:šªâñ” ï9å`ñ”dò9
¡ñ”$‰:­Š<:-/ü¬=Lü;Aö‘Õ;ËüÝ;RË’ü´<"¦“”³= è^  ñ”è^𤤠í=šž• Æ=à`ñ”TÉ=
£ñ”$Þ=­Š<ä=-/üô>(D?è^š¦¦šð‡ ‹?
¥Ö` üâ@%è^ü‡C#ü×B/, Extension trait for `Result<T, DataError>`.Á|C¨©¨©Ï÷,¥C©â ¡C¨Ï÷+Ï÷ªª*,ü¢DDü±Cli Propagates all errors other than [`DataErrorKind::IdentifierNotFound`], and returns `None` in that case.ÁÔ¥DøÞê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>˜™è^¨¨
ªøÞ˜™$ÀDüêD3¬¬ð‡ ïDˆ`­ª­ü¤ECÔ§Eˆ`ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>Ö`è^««
­Ö`$ÂEüï)2ˆˆˆˆ&ˆ&ˆ\¤*<¨*ÁûÏШIJ³Æ²³ÍòÁ]²´,†à`²µã`²µ¦$»b²¦Áb²ì²·T‡
´¸´Ð¹Lì–„û‡„‘d„§AÜö1ü€08¡¡˜dºæ`ºü·4º¢£¤ ¢˜d £Á`Á`œÃ`è Á]Ä`ŸÁ]Ê­\É:•¤Ù¹ ¾¹
º8$¿þ Åü¬#ܼ¼Žc½¾¿±ü¢1üÖGD Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataLocale`].ÁT© Ü
´
´
µlanguageÁ
scriptÁ
·regionÁ
¸variantÁ
¹ subdivisionÁ m´‘—J4Žc»»
½Üâ@4´ü…Qü¯QN Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataMarkerAttributes`].Á¬Œ ÜØdŽc»»
¾ÜÉ@Œ¢ü¦ü½da Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataMarkerAttributes`] and [`DataLocale`].Áü­ ä¥Ê£Žc»»
¿ÜÉ@Œ×â@4ŒüÜ=&8¥¥ÄeÁÅÁ¤‰><Œ>ÄeÀÀ
Á8üÏ>#ØdÃÄíîÄ\ù>4þ>ÂÂüž? ,¡?¦ ¦Ød ¦Ødí §?Â
Ä$¨?üÞ?#ØdÆá`Æü–@8™@§¨© §Ød ¨Á`Á`œÃ`è Á]Ä`ŸÁ]Ê­\É:•©ÙÅ @Å
Æ$ž@þ ¤@ÌÎAØdÈÉÊËÌÍü®B>D·B²ª ªÊ}ó›Ç ÃBÇÉ¡öÑMüÔFHü¨EGD Creates a borrowed [`DataMarkerAttributes`] from a borrowed string.ÁôEËüüESP Returns an error if the string contains characters other than `[a-zA-Z0-9_\-]`.ÁdáF« «ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ «ØdèeÇ ñFÇÚ¦öÝOüÆKSüÔGda Attempts to create a borrowed [`DataMarkerAttributes`] from a borrowed UTF-8 encoded byte slice.Á½HËtÅHÈîØHË<àHÚüìH!ê’IËôšI let bytes = b"long-meter";Áü½IEB let marker = DataMarkerAttributes::try_from_utf8(bytes).unwrap();Áü‡J1. assert_eq!(marker.to_string(), "long-meter");Á<½JÚÉJËdÑJ # ErrorsÁâJËüêJWT Returns an error if the byte slice contains code
1´‡
 Sets the checksum.Ál©
”f”fÝÝ
Þ
×CD½
Òü± @= A container for data payloads returned from a data provider.Áò Ëüö `] [`DataPayload`] is built on top of the [`yoke`] framework, which allows for cheap, zero-copyÁü× 63 operations on data via the use of self-references.ÁŽ
Ëü’
mj The type of the data stored in [`DataPayload`] is determined by the [`DynamicDataMarker`] type parameter.ÁËÌ„ ## Accessing the dataÁžËü¢b_ To get a reference to the data inside [`DataPayload`], use [`DataPayload::get()`]. If you needÁü…c` to store the data for later use, you need to store the [`DataPayload`] itself, since `get` onlyÁüé30 returns a reference with an ephemeral lifetime.ÁËÄ¡ ## Mutating the dataÁºËü¾TQ To modify the data stored in a [`DataPayload`], use [`DataPayload::with_mut()`].ÁËü—0- ## Transforming the data to a different typeÁÈËüÌ`] To transform a [`DataPayload`] to a different type backed by the same data store (cart), useÁü­@= [`DataPayload::map_project()`] or one of its sister methods.ÁîËÜò # Cargo feature: `sync`ÁŽËü’c` By default, the payload uses non-concurrent reference counting internally, and hence is neitherÁüöa^ [`Sync`] nor [`Send`]; if these traits are required, the `sync` Cargo feature can be enabled.ÁØËÈîëËüï1. Basic usage, using the `HelloWorldV1` marker:Á¡ËÚü­%ÔïüÓ!êÌõŽðËü“FC let payload = DataPayload::<HelloWorldV1>::from_owned(HelloWorld {ÁüÚ'$ message: Cow::Borrowed("Demo"),Á< });ÁŠËüŽ.+ assert_eq!("Demo", payload.get().message);ÁÚÕááïË ÜXŒßÏgÔ«|oPŸ¥à⪮ÏgÒ\ª®Ïgßß
àXtvôòßߪ®#ü”B? A container for data payloads with storage for something else.Á×ËüÛMJ The type parameter `O` is stored as part of the interior enum, leading toÁü©NK better stack size optimization. `O` can be as large as the [`DataPayload`]Áüø1. minus two words without impacting stack size.ÁªËÈî½ËüÁ! Create and use DataPayloadOr:ÁãËÚüï «ïü%Ôïü¶!êüØ$! use icu_provider::DataPayloadOr;ÁýËüA> let response: DataResponse<HelloWorldV1> = HelloWorldProviderÁÜà .load(DataRequest {ÁüßJG id: DataIdentifierBorrowed::for_locale(&langid!("de").into()),Áüª  ..Default::default()Á })ÁüÖ*' .expect("Loading should succeed");ÁË´… let payload_some =ÁüœJG DataPayloadOr::<HelloWorldV1, ()>::from_payload(response.payload);ÁüçIF let payload_none = DataPayloadOr::<HelloWorldV1, ()>::from_other(());Á±ËµñÜÅ payload_some.get(),ÁÄá Ok(&HelloWorld {Áüú(% message: "Hallo Welt".into()Á’ÑÎ÷üµ -* assert_eq!(payload_none.get(), Err(&()));ÁÚë ËÔï  Stack size comparison:ÁŠ!Ë<Ž!ÚÜ–! use core::mem::size_of;Áü²!!êüÔ!$òÎù!Ëüý!(% const W: usize = size_of::<usize>();Á¦"Ëôª" // Data struct is 3 words:ÁüÉ"52 icu_provider::data_marker!(SampleV1, [usize; 3]);Áÿ"Ëüƒ#63 // DataPayload adds a word for a total of 4 words:Áüº#:7 assert_eq!(W * 4, size_of::<DataPayload<SampleV1>>());Áõ#Ëüù#/, // Option<DataPayload> balloons to 5 words:Áü©$B? assert_eq!(W * 5, size_of::<Option<DataPayload<SampleV1>>>());Áì$Ëüð$@= // But, using DataPayloadOr is the same size as DataPayload:Áü±%@= assert_eq!(W * 4, size_of::<DataPayloadOr<SampleV1, ()>>());Áò%Ëüö%RO // The largest optimized Other type is two words smaller than the DataPayload:ÁüÉ&HE assert_eq!(W * 4, size_of::
```no_runÁüÏB%ÔïüõB!ê—CËü›C30 let resp1: DataPayload<HelloWorldV1> = todo!();ÁôÏC let resp2 = resp1.clone();Á<îCÚÕïË ûC‰ËŒ¤DÞØ}Â,ìDÏg˜ß˜>@¿D¼ùD,üDµ µÏgÏg ‚E
˜X$ƒEüåF’Õš©!šïË êF‚ß íF‰ËŒ›GœÞØ}œÂ,ãGÞ¼h,ñG‰hßUWZ\¶G¼þG,H ‰h‰h ‡H
X¼h$ˆHü‚L„ÕŸŸïË ‡L‰ËŒ´L žØ} ÂƒÿLüLÏg¡ ¡BDÏLüM"M·¸ ·Ïg ¸Ïgž “Mž
¡X$”Mî ,šMüÜM—Õ£©!¤£¤ïË áM‚ß äM‰ËŒ–N¥žØ}¥ÂLÞN£¼hðN‰h¦ ¦Y[^`±NüúN"ýN¹º ¹‰h º‰h¢ €O¢
¦X¼h$Oî ,‡OüÂPvÕ¨¨ïË ÇP‰ËŒíP©£Ø}©ÂµQÏg35ˆQü¾Q‰Õ«©!¬¬«ïË ÃQ‚ß ÆQ‰ËŒñQ­£Ø}­Â¹RœÄR‰hCEHJŒRüóW6Õ¯¯ïË øW‰ËŒ—XÏg°±²¸¹½ÂÇÍÏÑÓ68ü÷\.ü°XEB Convert a fully owned (`'static`) data struct into a DataPayload.ÁúXËü‚Y0- This constructor creates `'static` payloads.Á·YËt¿YÈîÒYË<ÚYÚüæY%ÔïüZ!ê̶ZŽðÔZËüÜZ# let local_struct = HelloWorld {Áü„[2/ message: Cow::Owned("example".to_owned()),Á4»[ŒþÆ[ËüÎ[PM let payload = DataPayload::<HelloWorldV1>::from_owned(local_struct.clone());Á£\Ëü«\-* assert_eq!(payload.get(), &local_struct);Á<Ý\ÚTþ\Ø}Ïg®®
°X‡®$‰]ü¥_Bü©^85 Construct a [`DataPayload`] from a static reference.Áæ^Ëüî^$! This is mainly used by databake.Á|²_ÆÓÏg®®
±X‡®¤Vü÷hÍü¥`2/ Mutate the data contained in this DataPayload.ÁÜ`Ëüä`\Y For safety, all mutation operations must take place within a helper function that cannotÁüÅa-* borrow data from the surrounding context.Á÷aËtÿaÈî’bË„šb
Basic usage:Á¯bË<·bÚüÃb0- use icu_provider::hello_world::HelloWorldV1;Áüøb!êžcËü¦cLI let mut payload = DataPayload::<HelloWorldV1>::from_static_str("Hello");Á÷cËüÿc@= payload.with_mut(|s| s.message.to_mut().push_str(" World"));ÁÄdËüÌd52 assert_eq!("Hello World", payload.get().message);Á<†eÚeËüšeSP To transfer data from the context into the data struct, use the `move` keyword:ÁòeË<úeÚü†f0ˆü»f!êáfËüéfLÙºgËÔÂg let suffix = " World";ÁüágC@ payload.with_mut(move |s| s.message.to_mut().push_str(suffix));Á©hËü±h5<ëhÚDþh ÜÏg×&®Ü³×&´´³®©â¿“ ‹i¿“<·iµ¿“ µØ}ÜÂüÁi?µ¿“ ”üÉi7
Ø}Ø}ü™j*
²XÜ¿“$–iþ œi‡i˜šÅiüßqGüÕm  Borrows the underlying data.ÁúmËü‚n]Z This function should be used like `Deref` would normally be used. For more information onÁüänC@ why DataPayload cannot implement `Deref`, see the `yoke` crate.Á¬oËt´oÈîÇoË<ÏoÚüÛo0ˆüp!ê¶pËü¾pGD let payload = DataPayload::<HelloWorldV1>::from_static_str("Demo");ÁŠqËü’q.¨É<ÅqÚæq· ·Ïg ·Ø}·Â®êq®
X$òqü´uYüÕs74 Borrows the underlying data statically if possible.ÁtËü™tol This will succeed if [`DataPayload`] is constructed with [`DataPayload::from_static_ref`], which is used byÁ¤u baked providers.ÁT»u» »Ïgø°ú°û°Ðü°ý°þ°ìHˈXêE> Ø}® Æu®
¸X$ÇuüÂ…Ìü¹w[X Maps `DataPayload<M>` to `DataPayload<M2>` by projecting it with [`Yoke::map_project`].Á™xËü¡xYV This is accomplished by a function that takes `M`'s data type and returns `M2`'s dataÁüÿxYV type. The function takes a second argument which should be ignored. For more details,ÁüÝy  see [`Yoke::map_project()`].ÁzËüŠz\Y The standard [`DataPayload::map_project()`] function moves `self` and cannot capture anyÁüëzXU data from its context. Use one of the sister methods if you need these capabilities:ÁÈ{ËüÐ{QN - [`DataPayload::map_project_cloned()`] if you don't have ownership of `self`Áü¦|>; - [`DataPayload::try_map_project()`] to bubble up an errorÁüé|GD - [`DataPayload::try_map_project_cloned()`] to do both of the aboveÁµ}Ët½}ÈîÐ}ËüØ}FC Map from `HelloWorld` to a `Cow<str>` containing just the message:Á£~Ë<«~Úü·~%Ôïüá~!ê̇Žð¥Ëü­^[ // A custom marker type is required when using `map_project`. The DataStruct should be theÁüQN // target type, and the Cart should correspond to the type being transformed.Áæ€Ëüî€%" struct HelloWorldV1MessageMarker;Áü˜:7 impl DynamicDataMarker for HelloWorldV1MessageMarker {Áü×,) type DataStruct = Cow<'static, str>;Á,ˆ‚ˆü’‚Ëüš‚LI let p1: DataPayload<HelloWorldV1> = DataPayload::from_owned(HelloWorld {Áüë‚.+ message: Cow::Borrowed("Hello World"),Á<žƒÉªƒËü²ƒ0- assert_eq!("Hello World", p1.get().message);ÁçƒËüïƒZW let p2: DataPayload<HelloWorldV1MessageMarker> = p1.map_project(|obj, _| obj.message);Á΄ËüÖ„.+ // Note: at this point, p1 has been moved.Áü‰…(% assert_eq!("Hello World", p2.get());Á<¶…Ú\É…Ïg¿“ßßàß âì Ô«|oPŸ¥Ÿ'®Ÿ'º×&»º»®©âð«Õ…ô“ م𫌑†¼¿“Ø}¼ÂŠÑ‚Ñ{·Ë…YÚ ¼ü¯†¼¿“á¬ð«¼Âü¢‡(Þ”üã‡*
¹Xð«¿“$Ü…þ â…Þàâ䳆üß’¥üðŠ[X Version of [`DataPayload::map_project()`] that borrows `self` instead of moving `self`.ÁЋËtØ‹Èîë‹Ëüó‹B? Same example as above, but this time, do not move out of `p1`:ÁºŒË<ÂŒÚüÎŒ,) // Same imports and definitions as aboveÁüÿŒ'$ # use icu_provider::hello_world::*;Áü«# # use icu_provider::prelude::*;ÁÜÓ # use std::borrow::Cow;Áüó'$ # struct HelloWorldV1MessageMarker;ÁüŸŽ<9 # impl DynamicDataMarker for HelloWorldV1MessageMarker {ÁüàŽ.+ # type DataStruct = Cow<'static, str>;Á<“ºüŸËü§LÕ¦üø.«§É·Ëü¿0ü§ôËüü41 let p2: DataPayload<HelloWorldV1MessageMarker> =Áüµ‘<9 p1.map_project_cloned(|obj, _
ü¶£<9 obj.message.to_mut().push_str(string_to_append);ÁÜ÷£ Ok(obj.message)Ád—¤ })?;Á¨¤Ëü°¤-* assert_eq!("Hello WorldExtra", p2.get());Áü⤠ # Ok::<(), &'static str>(())Á<‡¥Ú|š¥Ïg¿“ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶À«Ÿ(®Ÿ'Ã×&ÄŸ(ÅÃÄÅ®¥¬ª¥ô“ ®¥©âªÁ ±¥À¬Œô¥Æ¿“Ø}ÆÂŠÑ‚Ñ{·Ë…YÚ Æü’¦¦Æ¿“«Âê³í³î³Òï³ìð³ñ³ò³ìäs{©¶È­ÆÂªÁü…§3Þ”üѧ*
ÂXð«¿“ªÁ$´¥þ º¥7:=@:=–¦üãµÂüçªXU Version of [`DataPayload::map_project_cloned()`] that bubbles up an error from `f`.ÁÄ«ËtÌ«Èîß«Ëüç«2¾¹ž¬Ë<¦¬Úü²¬,±¯üã¬'ç¯ü­#˜°Ü·­İü×­'é°üƒ®<š±üÄ®.à±<÷®ºüƒ¯Ëü‹¯LÕ¦üܯ.«§<°É›°Ëü£°0ü§ذËüà°#Ü»üˆ±74 let p2: DataPayload<HelloWorldV1MessageMarker> = p1Áüı*' .try_map_project_cloned(|obj, _| {Áüó±'ʼüŸ²,û¼lв°½üâ²2/ let mut message = obj.message.clone();Áü™³85 message.to_mut().push_str(string_to_append);Á¼Ö³ Ok(message)Ádò³°¾ƒ´Ëü‹´?< // Note: p1 is still valid, but the values no longer equal.ÁüÏ´,) assert_ne!(p1.get().message, *p2.get());Áü€µ-Ò¾ü²µ ‰¿<׵ڴ굘¶ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ÿ(®Ó'ÈŸ'É×&ÊŸ(ËÈÉËÊ®·ˆ¶¡· Œ¶©âÜÌ ³·ŒÙ¶Ì˜¶ Ó'Ø}ÌŠтÑ{·Ë…YÚ Ìü÷¶­Ì˜¶êÍê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¸ÌÂÜÌüñ·3
ÇXÓ'Ͷ˜¶ÜÌ$™¶þ Ÿ¶,ADGJDGû¶ü÷Ämüß½WT Convert between two [`DynamicDataMarker`] types that are compatible with each otherÁü»¾$! with compile-time type checking.Áä¾Ëüì¾SP This happens if they both have the same [`DynamicDataMarker::DataStruct`] type.ÁÄ¿ËüÌ¿`] Can be used to erase the marker of a data payload in cases where multiple markers correspondÁä±À to the same data struct.ÁÒÀËüÚÀIF For runtime dynamic casting, use [`DataPayload::dynamic_cast_mut()`].Á¨ÁËt°ÁÈîÃÁËlËÁåøüÝÁ%Ôïü‡Â!ê­ÂËôµÂ struct CustomHelloWorldV1;ÁüØÂ30 impl DynamicDataMarker for CustomHelloWorldV1 {ÁüÃ.+ type DataStruct = HelloWorld<'static>;Á,ÃÈüÍÃËüÕÃ96 let hello_world: DataPayload<HelloWorldV1> = todo!();Áü“ÄEB let custom: DataPayload<CustomHelloWorldV1> = hello_world.cast();Á<ÝÄÚ$þÄÏgÀ«®Ÿ'Îή¥¬ƒÅÀ¬ü¶Å-ð«Ø}ÔÈÅ
ÍXð«$‡Å68ü½Êsü¼ÇW¶Ïü˜È$—ÐÁÈËüÉÈSÑСÉËü©É`ºÑäŽÊ£ÒDÄʼ ¼Ïg ¼À«®Ÿ'ÐÐ ÑÊ®¥¬ÍÊÀ¬ü‚Ë- ØÔ”Ë
ÏXð«$ÒÊ,.üâÞlüèÌQN Convert a [`DataPayload`] to one of the same type with runtime type checking.Á¾ÍËüÆÍIF Primarily useful to convert from a generic to a concrete marker type.Á”ÎËüœÎ]Z If the `M2` type argument does not match the true marker type, a `DataError` is returned.ÁþÎËü†ÏA> For compile-time static casting, use [`DataPayload::cast()`].ÁÌÏËtÔÏÈîçÏËüïÏGD Short-circuit a data request reque
tuplevarÁEÞ
vartupleÁEð
Ý0·

ÄAsULEÁ-§4

ÉEqULEÁ-ÞA

Í
SliceAsULEÁU„C

ÎØ
5Ýd

ÓUleErrorÁE؇

ÊCharULEÁ=‰

Æ
EncodeAsVarULEÁuâ

­MultiFieldsULEÁu

à

NicheBytesÁU¡

 NichedOptionÁe­

ô
‚£
õ
NichedOptionULEÁ}»

 OptionULEÁMÞ

× OptionVarULEÁeé

ö RawBytesULEÁ]‡

©  ¤
ª Ý0÷ƒ
 ·Ø
5Ɇ
 ¸üÏ?îñßâü”SÕØÂÅ®±šˆvÌügü›/3$ü‹$üöc` Trait marker for data structs. All types delivered by the data provider must be associated withÁüÚ&# something implementing this trait.ÁËü…WT Data markers normally generated with the [`data_marker`](crate::data_marker) macro.ÁÝËäá Also see [`DataMarker`].ÁþËü‚eb Note: `DynamicDataMarker`s are quasi-const-generic compile-time objects, and as such are expectedÁüè\Y to be unit structs. As this is not something that can be enforced by the type system, weÁüÅYV currently only have a `'static` bound on them (which is needed by a lot of our code).ÁŸËÈî²Ëü¶>; Manually implementing DynamicDataMarker for a custom type:ÁõËÚü !êÌ£ Žð½ ËüÁ 1. #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]Áüó  struct MyDataStruct<'data> {Áü”
!ãý
ˆü¼
ËôÀ
 struct MyDataStructMarker;Áß
Ëüã
30 impl DynamicDataMarker for MyDataStructMarker {Áü— 0- type DataStruct = MyDataStruct<'static>;Á ˆüÎ ËüÒ 52 // We can now use MyDataStruct with DataProvider:ÁÔˆ  let s = MyDataStruct {Áü£ 2/ message: Cow::Owned("Hello World".into()),Á ŒþüÝ C@ let payload = DataPayload::<MyDataStructMarker>::from_owned(s);Áü¡
52 assert_eq!(payload.get().message, "Hello World");Á<×
Úß
Ëüã
'$ [`data_struct`]: crate::data_structÁŒ•ðÞü‹ÉøÞðÞ%ݲðÞ1ݲ*‘©âøÞü¬&À³¤½•³'³³ü¬%ü¶\Y A type that implements [`Yokeable`]. This should typically be the `'static` version of aÁ„—
data struct.ÁT±ÁüÀ'üÖ?< A [`DynamicDataMarker`] with a [`DataMarkerInfo`] attached.ÁËüš[X Structs implementing this trait are normally generated with the [`data_struct!`] macro.ÁöËüú`] Implementing this trait enables this marker to be used with the main [`DataProvider`] trait.ÁüÛ`] Most markers should be associated with a specific marker and should therefore implement thisÁ trait.ÁÇËüËTQ [`BufferMarker`] is an example of a marker that does _not_ implement this trait.Á Ëü¤^[ Note: `DataMarker`s are quasi-const-generic compile-time objects, and as such are expectedÁüƒ\˜©üàYý©ºËü¾(% [`data_struct!`]: crate::data_structÁüç)Чü‘.+ [`BufferMarker`]: crate::buf::BufferMarkerÁðÞüÀŽà÷ŒÖðÞ"à÷ðÞ.à÷*”Ô±üî>; The single [`DataMarkerInfo`] associated with this marker.Á$·™mü‚+üÐ1. Extension trait for methods on [`DataMarker`]ÁÏ÷øÞT›Ï÷(¹½Ï÷4¹½*–˜˜˜üðcü´74 Binds a [`DataMarker`] to a provider supporting it.Á$ó§\Ãã9ÆÑ9NÇÞ9NK7S¹œ¹—øÞ§\ÛÜñ øR§\øÞ”À
øÞ§\Çã+-ü±8üØTQ Constructs a [`DataLocale`] using fallback preferences from this [`DataMarker`].Á\´
Û
Û‡Ÿ
Üä¢

Ýõ¢

Þ„£

ß“£

ࣣ

á ue_regionÁ
ûk'hTõ ¥Ð£
˜øÞâ@4Àüí/ÕššïË,‚ÿËX›˜ òü£c§\í[ÛœœÜñ «ôñ”ó
X§\Çã "üÆ7úÀУ
Xâ@4Õüá&OÍŸŸ™î æ& À—j d£'æi¡+-œ'|·'T¼'žž—jüÏ'HÍ££™î Ô'¤À—j¤dŠ(æi¥+-ƒ(Ôž($¤(¢¢™mü¥0.üá):7 Implements `DataProvider<NeverMarker<Y>>` on a struct.Áœ*Ëü *.+ For more information, see [`NeverMarker`].ÁÏ*ËtÓ*Èîâ*Ë<æ*Úüî* «ïü+%Ôïüµ+*' use icu_provider::marker::NeverMarker;Áüà+!ê‚,Ë´†, struct MyProvider;Á,Ëü¡,GD icu_provider::marker::impl_data_provider_never_marker!(MyProvider);Áé,Ëüí,HE let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(Á¤¶- &MyProvider,Á¬Ë- DataRequest {Áüá-KH id: DataIdentifierBorrowed::for_locale(&langid!("und").into()),Áü­. êÐTÎ.¼÷4Ù.Î÷à.ˬä. assert!(matches!(Á|ú. result,Á¼Š/ Err(DataError {Áü¢/0- kind: DataErrorKind::MarkerNotFound,ÁtÓ/ ..ÁTâ/’Ñ<í/ ));Á<õ/Ú¡ÿ/ ‚0 ‰08°4ƒ0tý/&|•0 Ô0 ±5 Ú0 ã0, Û08Ü0& Þ08ª $ß0*å0 è0 ®5)8$ò0 ö08Í ÷0 ø0, ú08
4—1'18ÒD\Ÿ1 ª18Í «1¬18
¯1, ³18´18$,¿18
Ñ1 Ô1:ÜÕ1 ×18Í Ù1& Ú1, Ü18,Ý1'â18â <ä1'ë18Õ$í1'ñ18ǾDó1 û1:Üü1 þ1$ ÿ1 ‰2 ¨58 —28Ù $š2 ž2 í2
 °28$±2$ µ28 áÇ2& Ê2, Ì28,Í2'Ò28¼=\Ô2$ ß2(ï28ý4ò2 ø2, ù28,ú2'ÿ28È+d3 3, Ž38,3'”38
43'œ38ÒD\ž3 ©38Í ª3«3$ ­3, ¯38,°3'µ38·<L·3 À3 Î3 ž58à3 ã3 5 , ä38,å3'ê38‰:lì3'ù38õ:tû3 ‰48ªDŠ4 4 5 ¨4, ©48,ª4'¯48
4±4'·48ÒD\¹4 Ä48Í Å4 Æ48È4, Ë48,Ì4'Ñ48ƒ.TÓ4 Ý4'Þ48•.$à4$ ä48 áú4$ ý4% ¯5üÊ5!q¬é8Ìj©ªäÇ9ü…9=: Magic bytes to locate [`DataMarkerIdHash`]es in binaries.Á\Ñ9¨¨™Êü¡:&üô9(% Gets the hash value as a byte array.ÁD®:Ìj벨¨
ª[ Å:üðB'LùBà ÃÊ} ŠC·êŒÓgü£H6d¬H‹Á¢$½HÉÓCkŒäH4êHŒƒI4‰Iü¿QÌj±²³
Ê
Ë
̲³DåQêQ°°ÌjüˆR"dRÌjÌj
桡
²$˜RüÒR/tÕR‹ÚÌj°°
³ unalignedÁLäRüÅS&ÌjüöVƒl¶ üªW"­WÄŠăl Ńlµ °Wµ
$±Wî ,·WÌøWƒl¸Ä¸ü¦X2©XÆÇ ƃl ǃlüÕýÕþÕLessÁÿÕ€ÖÖ‚ÖƒÖ„ÖGreaterÁ…ÖiÒ6’<Ë· ­X·
¸$®Xî ,´Xü‡Y ƒlºËºü¼YB\¿YÈÉ Èƒl Ƀlø°ú°û°Ðü°ý°þ°ìHˈXêE>ðܹ ËY¹
º$ÌYî ,ÒYü¨Z&ƒl¼¼b¼üãZ4$æZÊË Êƒl ËË1»Ë1½½ ‚[»©â£à ëZÃb£à”îZ
¼£à$ƒ[,‰[,.ŒÁ[ƒl¿Àü»]Q¡Û[ Þ[ å[8°4ß[tÙ[LÈ]Ɔê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ƒlƆ¾¾
¿ÿ
czüüf-üõc;8 Gets a platform-independent hash of a [`DataMarkerId`].ÁµdËü½d74 The hash is 4 bytes and allows for fast comparison.ÁùdËle
# ExampleÁ“eË<›eÚü§e!êÍeËüÕe41 icu_provider::data_marker!(FooV1, &'static str);ÁŽfËü–fGD assert_eq!(FooV1::INFO.id.hashed().to_bytes(), [198, 217, 86, 48]);Á<âfÚ4‰gƒlÌj¾¾
Àê~ü˜s"™mÂËÂüÁsB\ÄsÌÍ Ì™m Í™mØÞÁ ÐsÁ
Â$Ñsî ,×sÜ­t™mÄÄÄüÏt2ÒtÎÏ Î™m Ï™mðÜà ÖtÃ
Ä$×tî ,Ýtü¬u(™mƼbÆüÛu4$ÞuÐÑ Ð™m Ñ£àÅË1ÇÇ úuÅÐà ãuáà”æu
Æ£à$ûu,v$&œ·v™mÉÊËüòv.äÑv See [`Default::default`]Á<ÿvƒl™mÈȱ°×=6€ü–‚@üðyVS Returns [`Ok`] if this data marker matches the argument, or the appropriate error.ÁËzËüÓzSP Convenience method for data providers that support a single [`DataMarkerInfo`].Á«{Ët³{ÈîÆ{Ë<Î{ÚüÚ{%Ôïü„|!êª|Ëü²| icu_provider::data_marker!(Á„Ö|
DummyV1,Áüë|74 <HelloWorldV1 as DynamicDataMarker>::DataStructÁ4§}Î÷²}ˬº}ËÊüÔ}<9 HelloWorldV1::INFO.match_marker(HelloWorldV1::INFO),Át•~ Ok(())Á<¨~ùˬ´~ËÊüÎ~74 HelloWorldV1::INFO.match_marker(DummyV1::INFO),Á¼ŠÿÊü¦0ŸË×Ë’Ñùˉ€Ëü‘€/, // The error context contains the argument:Á|Å€µñÔÙ€ HelloWorldV1::INFOÁüø€(% .match_marker(DummyV1::INFO)ÁÌ¥ .unwrap_err()Á¤Ã .marker,ÁôÜ Some(DummyV1::INFO.id)Á4ÿÎ÷<Š‚Úd™m™mÜ€ÈÈ
Ê$ª‚
4°‚ü²„Aüñƒ<9 Constructs a [`DataLocale`] for this [`DataMarkerInfo`].Á\¹„™múÀУÈÈ
Ë$Å„â@4˄ĩŠÔц Creates a data marker.Áì†Ëtð†Èîÿ†Ë<ƒ‡Úü‹‡63 icu_provider::data_marker!(DummyV1, &'static str);Á<‡ÚʇËü·_\ The identifier needs to end with a `V` followed by one or more digits (the version number).Á®ˆËü²ˆgd Invalid identifiers are compile-time errors (as [`data_marker!`](crate::data_marker) uses `const`).Áš‰ËÌž‰ ```compile_fail,E0080Áü¸‰41 icu_provider::data_marker!(Dummy, &'static str);Á<í‰Ú&|õ‰!‰ Š Θ ÈŠ Æ‹, ÉŠ ÊŠ ׊+ ËŠ ÌŠ ÖŠ, ÍŠ8¡Ί& ÑŠ8«
$ÒŠ
ØŠ, ÚŠ8ÿ
$ÛŠ& ߊ8Û,àŠ$ åŠ, çŠ èŠ øŠ, éŠ8ã,êŠ& ïŠ8Ø <ðŠ$ ÷Š- ùŠ, ûŠ84üŠ& ‚‹8ƒ‹, †‹ ‡‹ ¾‹
$ ˆ‹, Š‹ ‹‹ ™‹+ Œ‹  ˜‹, Ž‹8«
$& “‹8«
$”‹
š‹, œ‹8
info_fieldÁT& §‹8Û,¨‹ ®‹, °‹8info_valÁD±‹& ¹‹8ï$º‹
¿‹, Á‹ ‹ Ä‹$ Ë- Å‹*È‹ Ë‹ ̘, Õ‹ Ö‹ Þ‹+ ׋ Ø‹ Ý‹, Ù‹8¡Ú‹
ß‹+ é‹ ê‹ ù‹8¹ të‹8ƒŒ84‡Œ, ŽŒ8ÿ
$Œ% “Œ8$Œ, ¢Œ8,£Œ'¨Œ8Ú-ŒªŒ8
¼Œ, ÀŒ8ÿ
$ÁŒ ÆŒ ÷Œ8!$ÔŒ8±TÙŒ äŒ, æŒ84çŒ% íŒ8$, 8,‡'Œ8ƒ.8
, 8ÿ
 £ Ƙ
88•.& », ½8'Ã8H Ô Ö »˜, è é ü“< ```rustÁ\ÿ+ ŸŽ  Ž ÚŽ8¡¡Ž ¥Ž8ï4§Ž ­Ž ®Ž ÙŽ7let ident = \"Á„¯Ž$ ¿Ž8µLÁŽ ÊŽ ËŽ ÑŽ, ÌŽ8ÿ
$ÍŽ$ ÒŽ7\";Á,ÔŽ+ ðŽ ñŽ  8¡òŽ öŽ8ï4øŽ þŽ ÿŽ Ÿ7let debug = \"Á„€$ , 8ã,“$ ˜7ê<µñ< debug.split('/').map(|s| {ÁüÚ"<9 let mut b = s.to_ascii_lowercase().into_bytes();Áü‘<<* b[0] = b[0].to_ascii_uppercase();Áüâ-<& String::from_utf8(b).unwrap()Áü¤‘)<’ÑTâ‘< .collect::<Vec<_>>()Áä< .join(""),Á”²’<
identÁlÙ’<Î÷4û’<Ú<–“+ ²“ ³“ Ä“8è,´“ ¹“ Ó8áLº“84Ú“8 DebugTestÁLá“% ê“- ý“+   ¢”8è,‘” –” ¡”8
unused_mutÁT—”8ñ”8õ”8infoÁ$ù” þ”8,€• †• œ—, ˆ•8,‰•'Ž•8Ht'ž•8¬2< • §• ›— 8,¾•, Ä•8,Å•'Ê•8
4Ì•'Ò•8²GdÔ•'à•8Ù1Lâ• ë• ý•8µLì• õ• ö• ü•, ÷•8ÿ
$ø• ÿ• š— 8Ò™– ›–  –8ª $œ–*¢–8ª $¥–$ ©–8Ö Æ– È–8 Ç–*Ê–8õ ,Í– Ò– Ó– ‡—8ï4Ô– Ú– Û– †—7Invalid marker name: Á¼Ü–$ ó–8µLõ– þ– ÿ– …—, €—8ÿ
$$ ˆ—% , ¯— °— —˜, Æ— Ç— З+ È— É— Ï—, Ê—8«
$Ë—
Ñ— ç— …˜8ч$è— ì—, í—8ïúTî— ù—, û—8©ûDü—% „˜
˜˜8ч$ª˜% ¼˜üј"™mÎá`Îüú˜4ý˜ÒÓÔ Ò™m ÓÁ`Á`œÃ`è Á]Ä`ŸÁ]Ê­\É:•ÔÙÍ Í
Î$‚™þ ˆ™ü¹œU±ÐЩâ÷nT¾œÑÀ÷nѤʜÆnÒ-/Μ|•ÏÏ÷nüø,<2‰2‰D‰D‰V‰V‰t¶-üË-96 Additional [`DataMarker`](super::DataMarker) helpers.Á4¾-ןü¹.¦Ø§¡.l„/Ú²Gd“/Û±E„¡/óÜ©Id³/¯ÝÒD\Á/çÞü¥.3tüæ.mceUWGI9;+-ŒØ/lÜ/áØ

ÓßàØ
 ¸ßà¤ÏüµA> A trait that associates a [`VarULE`] type with a data struct.Á÷ËüûJG Some data structs can be represented compactly as a single [`VarULE`],ÁüÆKH such as `str` or a packed pattern. This trait allows for data providersÁü’(% to use optimizations for such types.Á»Ëü¿SP â— Not all data structs benefit from this optimization. It works best when theÁü“NK data struct is multiplied across a large number of data marker attributes.ÁâËüæLI Both [`MaybeAsVarULE`] and [`MaybeEncodeAsVarULE`] should be implementedÁü³YV on all data structs. The [`data_struct!`](crate::data_struct) macro provides an impl.Ál—ááðÞü³áðÞðÞ ââªâøÞâüš$
Óš…šžšüš#ü«74 The [`VarULE`] type for this data struct, or `[()]`Áüç.+ if it cannot be represented as [`VarULE`].ÁlŸááÄ—
ü’ PM Implements required traits on data structs, such as [`MaybeEncodeAsVarULE`].Á&|ã h‰ °
 ÿ 
 ó
 ·
, ¸
8genericÁ
& À
8Û
& Æ
, È
8boundÁ
& Î
8Ï
 Ñ
, Ó
8Ô
& Ö
8ª $×
, Ü
 Ý
 ñ
$ Þ
, à
 á
 ï
+ â
 ã
 î
, ä
8Î
& é
8«

ð
- ò
*õ
 ø
 Ò'8$ , 8Ù›<ˆ& , 8‹œ,’ , 8'Ÿ8Ò4¡'¤8ç38
´, ¸8¹ ¼ í8!8ü3 Ý ß â à á% ã, ÷ ø , ù ú ƒ+ û ü , ý8Î
- 8$ , 8Ù›<& , Ÿ8‹œ ¥, §8'­8Ò4¯'²8Å
ϫ8
È, Ì8Í Ð Ì 8 Þ8maybe_encode_as_varuleÁ´á ÷ ý ø8(ÿ8Ó4‚ ˆ 8'Ž8ü3l  Ÿ Â8Ð% Ó Ù ú, Ú8Û& Ý8ª , ã ä ø$ å, ç è ö+ é ê õ, ë8Î& ð8«

÷- ù*ü ÿ µ8$‰, Ž8,'8Ò4'8ç3l8
©, ­8® ± â8!$¿8ü3 Ò Ô × Õ Ö% Ø, ì í ú, î ï ø+ ð ñ ÷, ò8Î
ù- û8$…, Š8,'8Ò4'8Å
œ—8
«, ¯8° ³ ¯ 8 Á8Ê¡´Ä Ú à Û8(â8Ó ë ì8'ñ8ü3   ¥8Ð$”%  ¼ ¹, Æ8Ç& É8Ê$ Ì8varuleÁ& Ü, Þ8ܨ& å8æ$ è, ò ó + ô õ , ö8Î& û8«

8encode_as_varuleÁ„Œ& œ, ž8ó©„Ÿ& ¯8ï*» ¾ ü8 Ì:'dataÁ Ò, Ô8'Ú8Ò4Ü'ß8ç38
ï, ó8ô ÷ «8!$…8ü3 ˜, š8ܨ4›% ¡, µ  ¿+ · ¸ ¾, ¹8Î
À8 Î:ߪ Ô, Ö8,×'Ü8Ò4Þ'á8Å
ϋ8
÷, û8ü ÿ ö 8 8Ê¡´ ¦ ¬ §8(®8Ó · ¸8'½8ü3l¿ Ì Î ì8 Ç8bind_lifetimesÁ Ø8×& Ù Ú Û à8þ Ü& Ý8×& ß(â8×& å8$8×& í& î8
ð ó:ߪ ù8û ý ˆ þ:ߪ,ÿ, 8(Š :ߪ, 8ܨ4• œ  8þ ž8  Þ8Û® Å ×, Æ8ó©„Ç Ø Ý8% ýüÌ!0åÍæåæð‡ Ñ!ÍtÔ!Îoèâ Ú!”ƒ"lˆ"ää
ÔÒ#Þoêâ”ó#lø#ééâ³\ë/üý/IF Traits that data provider implementations can use to optimize storageÁüË0.+ by using [`VarULE`](zerovec::ule::VarULE).Áþ0Ëü†1&# See [`MaybeAsVarULE`] for details.Áó/ç3lÐ1áìüº1#|ÿ2ü¸2FC Core selection of APIs and structures for the ICU4X data provider.Á<‡3à7ªïà7«ï“ <ð×2© Ìò‘4 ãó¡.Û ôÚñB¢ÏõñB¢Ðõ£@½¢¨ö½ö n÷·<Ô¢ëø¯‰:ï¢Ìù°¡
´úϸƒ.ûÔÿA
£ÁüЖH¡ýÕß ßþþß àþþ£¡Rÿ¼=ûÑø>ÒÈ+›¡éÿžCӃݶ¡YÚ-Ö¢С`ˆìê¡gÙ¢¨ˆ±Š¢
ÕŠÃüž4*“ “ üì4Ô© ©   ¬—5Û ä®5¢üÔ5½¢ö ö Ô¢Ô¢ï¢ï¢¡¡
£
£¡¡›¡›¡¶¡¶¡ССê¡ê¡¢¢¢¢K¢„;¡ö: ù: €;8°4ú:tô:üË) & Options to define fallback behaviour.Áõ ËüùS P These options are consumed by the `LocaleFallbacker` in the `icu_locales` crateÁüÍc ` (or the `icu::locales` module), but are defined here because they are used by `DataMarkerInfo`.ÁD—;åÏÜî èoŽôÈ ü 3 0 Const-friendly version of [`Default::default`].Á<Õ èoÍ‚ü‰
' èoŤ·
èo
Ì¢ •q’ôñ ü * ' Const version of [`Default::default`].Á<þ •q»€üí!% •q”Ť™" <œ" •q
\â?»Ð> Ó> Ä?8àÔ> ×> Ã?8Æ Ý> à> ô>8<á> é>7µLë>$ õ>8Æ û> þ> Á?8àÿ> ? À? 8焃?$ “?8<•? ?7á<Ÿ?$ ¦?8Æ ¨? «? ¾?8ØL¬? ¶?7¾ 4¸?$ ¿?üÎ>x¡É? Ì? Ó?8°4Í?tÇ?ê?,÷@º$§A˜ч$ÖAã,…BštraceÁ,µBüˆ@&|ô?x‰ ¨@ Ì@ ²@ ¿@, ³@ ´@ ¼@, µ@8 ¶@& ·@8ï$¸@$ ½@
¾@*Á@ Ä@ Å@% Æ@ÌÚ@ôÌŠAæÌ¹A×ÌèAÉ̘B¶ôüüª@= Regular baked data: a trie for lookups and a slice of valuesÁ$‡ÕïË ŒÿËTÖWpO~(ë-žŸ&(üö(œœïÉü¤ œœæÍ(ô-Õ¡¡ïËà`X3ÿËœà`Ø}FÖW¢á`¢ÁÃceÕÖ× ÕÖW ÖÁ`Á`œÃ`è Á]Ä`ŸÁ]Ê­\É:•×Ù ô