Files
boc/aamos-ledger-rust/target/debug/deps/libicu_provider-db5b46d656d85189.rmeta
T

2103 lines
334 KiB
Plaintext
Raw Normal View History

rust
8#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁzerotrieÁá}"SŽUMö@0=$_²-05178122ec16f752Á
displaydocÁ©$-.ÿæ§ï=[œiF-53df79815c011341ÁzerofromÁ/ŽErÅÉŽV 7Í-92c585200eab8211Ázerofrom_deriveÁŸæþÇŽá2?M¥e (-abe85a41d9dcc735Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁyokeÁ?9›Š´;1ˆOøÀ-f8bf9e5b8bbb2034Ástable_deref_traitÁ½ÊTýö÷n˜TóQ-á†-771635b0451f799dÁ yoke_deriveÁ×ã„Ô„ýT·+CIƒ•sÙ-ad663b8de2c8c776ÁzerovecÁ 
åLì{'h‚ïhïD¯Ð-719747d224e025f1Ázerovec_deriveÁ£½+d“ð΃-m*¸]-09ac241eaa4a8700Á writeableÁ²é´‘¥1§%‚ý uÈ%-735c33932dd69842Áicu_locale_coreÁ*WéŽu>9gà ¦$hs-18874daa5c5c87adÁlitemapÁÎ xj+Þ*`²ÔtJ²-5054981e83d0528aÁtinystrÁ ²ãЕ 'xË´BXßñÖ-607f5ace9a59a465Á¤,¦$»¤Œ…$ß»¤Œùù
»¤Œ°
:serdeÁ,½»æŒ¥exportÁ4®%»”‘% hello_worldÁ\Ø%»¤Œ¼%serde_borrow_de_utilsÁ¬Õ&»æŒ–&PBoxÁ«»¤Œ…PIterableDataProviderÁ¤µ»¤Œ—PIterableDynamicDataProviderÁÜ¢D»¤Œ„DP$„e$ùd¤Í(»¤Œ¡(¬Üã(»¤´oø»¤ŒÑ´ToOwnedÁ<ª»¤Œƒ´éß»¤Œ¹´ß4‘»¤Œê´®»¤ŒŸ´VarULEÁ4廤Œ¿´DataIdentifierCowÁŒÆ!»¤Œ§!Öé໤ŒºÖr,û¤Œ Ö
SelectedRcÁTÔ»¤ŒÖ »¤ŒæÖ CartInnerÁLì/»¤ŒÈ/áEncodeAsVarULEÁtø»”Ñá ZeroMapKVÁLÑ»¤Œ©áZeroMapÁ<Ü»¤ á ZeroMap2dÁL廤<MaybeEncodeAsVarULEÁœ¿
»” 
ñÝ œÆ1»1óAsDeserializingBufferProviderÁìƒ3»æŒ×2ó±
ŒÂ8»¤Œò7ó¤Õ8»¤ó¬Üë8»¤,.logÁ‡;»loggingÁœé:£<»¤Œë;íbakedÁ_ ID_SEPARATORÁ  get_indexÁžfrom_trie_and_values_uncheckedÁžžgetÁ žfrom_trie_and_refs_uncheckedÁž ž ÿ" DataForVarULEsÁ$ž$trieÁ$¼(ž*ž*Ä-ž-ÿ/  DataStoreÁ5ž5ÿprivateÁ8SealedÁbufÁ::<
DataStructÁ:BufferProviderÁ:?¡:Acheck_availableÁ constructorsÁCgen_buffer_unstable_docsÁCgen_buffer_data_constructorsÁdynutilÁFUpcastDataPayloadÁGžGupcastÁF__impl_casting_upcastÁFF__impl_dynamic_data_providerÁFF%__impl_iterable_dynamic_data_providerÁF
data_providerÁPPPP DataProviderÁTžT¬PWžW¡W¬PDryDataProviderÁ[ž[dry_loadÁP^ž^¡^àPDynamicDataProviderÁbžb load_dataÁPeže¡e©PDynamicDryDataProviderÁiži
dry_load_dataÁPlžl¡löPBoundDataProviderÁpžp
load_boundÁp bound_markerÁPtžt¡tÂtÓPyžy¡yæ P}ž}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ÁÉas_strÁ 
responseÁÖÖÖÖÖÖÖÖÖß
with_checksumÁÖ DataPayloadÁá
ážáˆÖ
DataPayloadOrÁå
åžå åˆÖDataPayloadInnerÁêžêYokeÁì
ìˆê StaticRefÁï
ïˆÖDataPayloadOrInnerÁòžò òà õ
õˆòInnerÁø
øˆÖDataPayloadOrInnerInnerÁûžû ûÜ þ
þˆû¯
ˆÖ¾ ÖÖ 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Áƒ Ãï
ƒ Ń
ǧȃÊfrom_idÁÊ match_markerÁʬ-ƒ data_markerÁƒÏ׃јÑÁјÚÙÙÙÙÙÙÙ
varule_traitsÁáá
MaybeAsVarULEÁã
EncodedStructÁá data_structÁáæ¥æŸæ æÝ2áëÝ2áíÁí§íÝ2uleÁñ¥ óóóóóóóóóó ó
ó ó ó
óóóóóóóóóóóóóóóó¸>>>>_internal_noop_logÁDataÁ¢ž¢ø¢¼ ¦ž¦×DataRefÁ©ž©ø©¼
­ž­×: BufferMarkerÁ°
:²×: BufferFormatÁ´JsonÁµ
´Bincode1Á·
´ Postcard1Á¹
:»×::¾:ÀÖ:§Ãù: :
: ǃPDataProviderWithMarkerÁɞɡÉinnerÁÉ_markerÁPΞΡÎ׌
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Á
í×ðƒóõÖ


"
"
/
/
7
7
B
V
V
W
Z
Z
]
]
^
a
a
d
d
e
h
h
k
k
l
o
o
r
r
s
t
w
w
x
ƒ
ƒ





¢
£
¥
»
¼
¼
¼
Â
Æ
È
È
È
Ê
Ë
Ì
Í
Ï






š
Ÿ
£
£
¨
¨
º
Ñ
Õ
â
ø
ø
ø
ü
®
¸
¸
º
º
¼
¼
¾
¾
Ä
Ä
Æ
Æ
È
È
Ð
Ð
Ð
¨
¨
¨
¯
¯
¯
³
³
³
¼
¼
¼
¿
¿
Á
Ã
Ã
È
Ñ
Ñ
Ñ
Õ
Ø
Û
Û
Þ
Þ
Þ
à
à
à
ø
û
þ
þ



Š
Š
Š




 
 
 
£
§
§
©
«
«
­
­
·
·
·
¼
Ã
Ã
Æ
Ë
Ë
Í
Ï
Ï
Ñ
Ñ
Ó
Ó
Ø
Ø
Ø
Þ
Þ
Þ
à
ã
ã
ê
ì
ì
ì
ó
ó
ó
ø
þ
þ
þ


ƒ


ˆ
ˆ
Œ



ž
ž
ž
¢
¥
¯
²
²
´
½
Ç
Ç
Ë
Ï
Ï
Ô
Ô
Ô
Ý
Ý
Ý
à
à
â
æ
è
è
ê
ê
î
î
î
ñ
ô
ô
ö
59>GT[bipªã¿c¢¢í5¤ø¥¼¢{rì¼ØÞž9ÔV5ÔVŒW¿c©©¤6«ø¬¼ߘ½—àYnŒW9®W5®WŒW9$$Ü&ø'¼‰d§Þ v¥ÖŒW5„XŒW¿c°°±Þ6 ‚º'M¾,¢^ÎX>¡¿c´µ–7·¸§7¹º¼7§ƒk±ùyoÐì‘Yµß‘Y‘Y‘Yše‘YŠ ‘YÛ‘YØ‘YT 8¡ž[¨Z´Zb¨Z´Zi¨Z´Zp¨Z´Z¿cÉÉ¡8ÌÏ8PÍÜ8P< ý”¿-ŒW¡pÉÉ¡8ÌÏ8PÍÜ8P< ý”¿-ŒW¡ªÛÒáâó9ãäŽ:åæ­:çèÈ:éˆêëí:ìˆíîŠ;ïð¢;»ú?„ÌZ؆\Š †\†\Ðì†\µß†\†\Äc†\¿c†\Ûññµ;òóÚôÖ;õé;Ç$EsÇ£ÚØð]Š ð]ð]Ðìð]µßð]ð]¿cð]Äcð]¾ð]ªÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥ð]à_³º<ƒÕ<Æ*W•¦6šÁ¿có_Ûó_Øó_Š ó_Ðìó_µßó_ó_ó_³ššö=é;œ™>˜Ñ´Öñó{¿cÿ`Ûÿ`Øÿ`Š ÿ`Ðìÿ`µßÿ`ÿ`ÿ`íßÿ`ÿ`ºÿ`³®®¡?°Ç?±à?”Щþh)íÁ¿cbÛbØbŠ bÐìbµßbbbÄc®®¡?°Ç?±à?”Щþh)í8ÐìÇÇý@È»´-ʪ—\Wíµßêcêcêcºêcíßêcêcšeêc³ 8êcé!êc¿cêc¿cÕÕÖïA ¾è¨üb1’¬¿cÙÙœBÚà?ÛÀBÜÕBžÆ› é4WîØªeÐìªeµßªeªe³ªeØææçCèˆÖ cd%»`^t¿cfï›f¿cááâÉäˆ ’G†qA–ŒW¿cååæñéˆ v˜ Á,|}QŒW ØèfØ£gµßèfèfµß£g£gèf£g³èf¿cëëª*íÆ*îÖ*Å‹· {äŒWزhŒW¿cííîÐCðˆƒ gUrªŠ „iØ„i„i„i¿cùùú¯Dûˆƒ Çø §ÐìëiµßëiëiëiíßëiëiºëiŠ ëiÛëiØëišeëi
°ëi
µëi
¹ëi¿c°Fšƒ§ƒcm³&O¡ÀŠ ¥kÛ¥kØ¥k¥kµß¥k¥kº¥kíߥk¥kše¥kŠ §§”G¨Õ<©²GªÆG«ÚGHƯ2Û¾lؾlÐì¾lµß¾l¾l¾líß¾l¾lº¾lše¾l¿c¾lصµ§H¹ˆƒ 08FÈàtñ˜Š îmÐìîmµßîmîmîmšeîm¿cîmîmãà_Ÿãã

VarZeroCowÁ
@

marker1Á
Œäó•{$Á§¿cÕÖ×¹JØÙÎJÚÛáJÿŽØšËÿèÐìéoµßéoéoéoŠ éoÛéoØéoíßéoéoºéo³éo¿cëëÑKìíK i,aÛ™qØ™qÐì™qµß™q™q™qŠ ™q³™q¦¢­©²°»´ÎÉßÒÿñˆŸšµ®ÇÇ×ÕÝÙëæŒáåõëñíýùϧѵÜÕí뢩($¢ ©-$<° íѵ?½´ÙÒüñ¥š¿®ÉÇáÙÿù°§ÁµÞÕòë¾´ÚÒýñ¦šÁ®ÊÇâÙ á¤åù·±§ÄµßÕóëÀ´×Òúñ¨šÄ®ÌÇ©á¬åù¤³§ÈµáÕõë´ÒÇŽù½Ç§ÌµÅ´ÖÒùñ¤š½®ôíùŸ¬§¾µãÕ÷ëÆ´ÓÒöñ¡š¸®Šù ­§äÕïëÇ´ÔÒ÷ñ¢šº®ßÙéæáåùëöíù¡®§ºµåÕðëW
^
e
l
t
}ÉÝÒñ»®©ñ­Ö¿š²®Â
äÙÚáÕ몚ÐÇù»Ã§çÕ¬šÎÇù¹Å§éÕÄÇæ¤íù²ùùæëí
¿cè9¨5>Ðì
µß[pšeiŠ
*Û [ØMT~[bipÄc
¾ª³íß6º*é!*ï
°
µ
¹ã0x1EÁ¬à ¢ŒW ôûü¸ÃÔV··ZeroTrieSimpleAsciiÁ¹ÈCØNwÐ#Á¶ 
•| 
ŒWš}Ùå}Íø.¼'Ÿ¬Ü  ©ŒW ð ÷ ü­Ê®Wš} 
è}4™ š}±ø*¼'Y$ç14í1¬à1 $ŒW ô1û1,ü„X$Ñ1š}$½0 

 VarZeroSliceÁ
Ú

 entire_sliceÁ
!3o±^<KÊè}ä
ä 
ä 
å Index32Á x/»õËCP4ï0š}ø€
ø¯¼*Þ,ð`\Œa ŒWüÝ`E ÉŒW¬[ ¡a¨a|ü°`xñZ$Î`¬[,Á`¬[ PhantomDataÁFu\»ŸŒW´Ï8Kl
 Û¼¥k Û¼ üþ ñ þüɼð]†\†\ÀÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥kùÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙþ„)¬ÎŒ£
"
/ ³ü£%


ž7œµ ÇÎüÕyð]L†\¾lð]Û†\Ú¾lœ)Ú-WŒë 
"߇- û <Ž!üë +

„ý 
Ÿ}7Ìý  •!œ!˜ü™ ƒð]†\þ„ð]Û†\Úþ„Ÿ+contextÁ5a
¬ü% Ò$§& Û¼¥kŒÆ&\Ë& Û¼þ„ Ö&üã%š ñ,í& ü&ƒ'ü¢%áð]$Ô%þ„\¶%†\æû…ÕdžÀþ„ÀÖ;+NLÆ(†\|å(Lê(¥k Û¼¥k ó()dž\µ)ü­(ž ñ Ê)Ñ)žüä'íð]$ž(ð]$ý'¾l4ƒ(†\ûû…ì¥këdž¼ª8Ú<gL+†\\º+û…là+<å+ Û¼þ„ ì+\ƒ,ü‚+— ñ ˜,Ÿ,Ÿüµ*êð]$ó*ð]$Ó*þ„<Ù*†\ûû…ìdžÜþ„ܬ:ÅŠ>j,ûB ƒC
üŽCÿ \”C ”C<˜C ˜C
$šC
Ús•|4,šC žCm~'-üåCŠ ù\¾|` 
ôC  $òC 
  
 \øC •|•|a   )\} 
 
\†D •|•|A  
\”D •|•|0   ‰\¾|  -_ G V•|•|9e ¡ °•|•|Z¿  *•|•|z: !\ø| 
 
º

­D œÌD ÕÄÈD Ö¿ýd ßD îD
 ·ŒE ŒE ¡E¢Ey ïD 
K
Q 4üD E$ 'Jü Cí Ž
 &-ø·ŽCÿ öüø™E 4–E Ö¿ýd ›E-,6Êü®Bôü÷B«˜Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ýdüÍBØ} ÀBâÆÁÁØ}IFC8? ÕÜ07ü¯D@ýdÇ=³»Âœ¾Ì´²dd»G »G#
*D½G
à|1T½GM ÆGü§G!

ϤG
Ì' ÇG ÍGÎGËüÔFzÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 êcýdüúF"þ„ îFØ}%Ø}-þ„(¾%œÔ±LTÀL
$t±L
Ê1A ÊLM4¨L ‰M ÎMTúMüÛM*

ôÛM
¸v4'PœêL ÕÄæL Ö¿á ýd ýLüßL „NüÌN- üÕN"
ü×N  |ØN ØN   êc öN @
 M 
üÉN1 Ö¿á ýd ùN ÿN 
€O ÌüÆKºü¤LÜüÊM¶
“ ü÷K"Ø}TáKüÑL8ýdL‹œØ}Ëþ„¼Ø}¼á ,á ,ÿ£, ,
code_unitsÁu¾
¹¬úU V
$”úU
Ë1Aù`@#
 á`#
ÜWùaž"#/ ŽV,òU õU«á  ÖV àV æVçV)¤
ù¹ž"#
¶cüªV!þ„
ÃÍü…Uâù`Üì#üîUyü¶U± á ,°Uþ„ ¤Uü•VA<äÈäÈ ArgumentsÁæÈtemplateÁ `çÈÀ `üöMõô]Tdoá D“ éþ„ên¾½vä
üX#ü’X!„“X“Xþ„8ÿ£ ²XXe ºX»XÎü W›á l¸Wá ²ÿ£±†¦°þ„°9\©Y ¹YºYÏüüX>þ„$šYá ,Yþ„b6üá_!$ý_ êŒW `üÜ_' áŒW ‚`‰`³ü_zèf$Í_´$¬_êìíà îˆïðÜ ñˆ!cfþ>Ÿ(nŒWÞ´ÜdataÁjüÙ(ˆdÎ)\Ï) •|7M l±) þ„ à)üÁ(¡
 ¼Á(
Ë( á)ü¤(¿§¾lt°(¥k؃°Ö°Ö=}à7


Àëi#)7BIq
x}
À•|Ÿ¥³¾Åíö<ä8 !,=O^j†žs{Š¡<ì9 ›³(5Ø} ò9üÍ9'«Ø},ä9†¶{†¶ƒ5b"tdmh"Á4Ø:›³ä:¬ü§:=›³<Æ:ëi$½: -T¹J ÆJ
ÑJ,×J\×J
 ÝJ’”1,ÝJ áJDìJ ÷J
üÿJ‰ Œ…Kd…K …K

4K  . 
?  
 V   K 
{  •K$ $¥K
ü¿KƒlÍK4ÓK'8 KŒèKTîK4îK ÷K= 'cKŒ °Œ‡LTL4L –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( €M$ ('J(ü—Kñ  ‡M
ćMè
ð^ øÄÿJ‰* =*CQüŽM¬,Œ‘M-dM.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>$ŒN??\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 ŒOL
šdæN»ÁJ¤KIº OKJüß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Ì‚J$‚J
"d‡J
øÑ04”J±
¤‡J šJüûI $¥J¯J¯ü±HþäHDÇH$ÖHYY÷Òѧ:ùÓ?jb°Ð±¹y7ž
0x9e_37_79_b9Á8Á$üÑ^oüÕ^0üÕ^|Õ^$Õ^
$DÚ^Ÿ/TÚ^ ã^tå^Tå^$å^  
$ê^
×| 1,ê^ î^ W
 ò^y 
'Ÿ
K
   )   =V
^tõ^
ó k„õ^ „_À_
 ¿_,Í_TÕ_$Õ_
$Ú_èÚ/ ,Ú_ ¬Ÿ_< _þ„!T©_$©_
$®_èÚ/,®_ ²_ƒ  ³_Ô›_ Ö¿¥kþ„ ´_ µ_@G# Þ_tÕ_ â_$ '
JKüí_M  üó_'´ó_|ó_$ó_
$Dø_Ÿ/ Tø_ `,ƒ` ƒ` ‡`= '
cKÍ Ù! ê ! ý
tŠ`¼Ü(„Š`B ™`4©`" ®`$ "'J"ü›` Ź`í
õ š ¦øÅí_M$ G$M ¹`üÃ`O&ôÆ`'´Æ`(|Æ`)$Æ`**
$DË`Ÿ*/)TË` Ô`*,Ö`+ Ö`,,-, Ú`= -,'c+-K,Í.)Ù/+.ê /.+ý()+'($à`V•|/' ã`+)(Dþ`1ÿ`233þ„!23 „a44I1 24 …a42lú` Ö¿¥k­ß1 †a1 ‡a3 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 b7 b9ü;$èb<<ü€ck=Dc> ˜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=<ü Ö¿¥k­ß; öc;6¤5«²X¹UÀRÇOÎKÕGÜCã?ýc# ÁüÉ]´üÉ_´üœaáüÏa®ZÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥k­ßü÷]#þ„$à]TR •|TØ}Sþ„Tþ„†ž1ü†_:­ßŠ þ„ þ„ n þ„o 

þ„
†žÞ  N ¨ö Ø} þ„ H H †žY  ½ †žj
Ù á è Á ¿ •|¿ Ø}¿ þ„À ƒ ƒ †žñ ø üå`-­ßÀþ„Áþ„ʤØ}ý›³èèØ}èØ}ðþ„ë¥k3þ„2ƒ°(•|''7>•|ÞÞîõ•|¥¬•|LL\c•|•|¬•|77F•|ÑÑàÐ ×´_magicÁC 5§1 6U «Ø}×gƒ°Ógƒ°Ïgƒ°Ëgƒ°h‚h†hŠh  Žh

T •| 
h
 üðg" ù ‘h —h˜hÂüŠgŽüÂgV ëi„§g¥k$žg•|•|;•|_•|ƒ›³•|•|•|•|ûSh1Áph2Ášh3ÁÄh4ÁîÒwüów
ìów
˜(ü¿w¹ §,®x,Ïx ÷yþyËü†wø¾l$°w¥k›w¥k³™q§Õ<<tˆ Õœ üß
= éo
üÎ"! 
üÎ" 
)ü±"I ë ù" €# ˜üˆ"x ™q$¢" éou„‚
 Òè%†\0¾l7>  Òë%†\0þ„8?üÅ, áŒWâ)èf4Ù®<Cü”(1 åŒW×gæ,£g7òõöà ÷ˆøù¹!úˆê‹ÁAžD:6ŒW×g$ª) êŒWí(Ù®4ŒŒà yokeableÁcartÁ  †|À§M
è}CartableOptionPointerÁÏ8Œ _cartableÁH_}öáf@ ÝäLë) êŒWð(Ù®4´;B$Ó* òŒW×gö+ކ7­‡?F,”+ òŒW×gù+ކ7ûþÿÜ ˆ¯ƒˆ|Ìô9
¸ŒW×gL„, ûŒW×gÿ+ÆŠ7´>E,«, ûŒW×g+ÆŠ7×g>E|å. æç%f0̈8?Ì»& í¶iî(„i3æ‚Fu\»Ÿ¶iahÜÈ8 ùú%ëi0›³8?üù›9 µ n*îm5æ‚Fu\»Ÿ ncj:CFPŒ´ÖƒÙáñóíöIJ(
Däƒ5
Eò¬ý JäÔ L¹üü0% N£Œ'pd°'T¡8´¾'ɈÃ|Ö'[ˆœç'bŠÒ´€(iµ;L)ñ±‡9l¨)Ò²½|·)ª³
DataLocaleÁTé)
ÖѺý@¤õ)ÇÒº<\*Óö=œ˜*šÔñl“+åýñæýC$µ+æÿÉ\»+áÉâª*dÈ+ëœB¤Ö+Ùž.ü¸0!¨¸1\ÊŠÎå,T¬,Ö”Gt¸,§×¼,ŒÈ,Øò2\žå»5”»?œ¡?´È®ÕïAœ¸AÕÕï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.Áúü‹30 ### [`BufferProvider`](prelude::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 [`BufferProvider`](prelude::BufferProvider)s:Áñúüõ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Á:CFPŒ´ÖƒÙáñóí÷öøD÷EòöJõL¹ôN£òpñT¡8ðɈÃï[ˆîbŠÒíiµ;ìñ±‡9ëÒ²½êª³ìà
ÖѺý@ßÇÒº<Þ
databake.Á­ úü±N K It can be glob-imported, and includes the [`icu_provider`](crate) prelude.Á úü„3 0 This needs the `"baked"` feature to be enabled.Á»ØŒ´$Ì®$,Ð$58¡?´à ®2üå,Tø 3ÖÉ\„ á4Éâ4„¹ üË-* Data stored as as [`ZeroTrieSimpleAscii`]Á ©¼,Œ’ØZeroFromÁDÊ
 ÓÁ4 È2láã ò¤|œº· ä€
ä ä€
å „€
©tß3>
ö¸1\£4Î
øò2\°4å
ùƒ-lÅ4
úÜ£Œ›5p
ýìTÈ5
Ö
Ѻå,TÜ5
ÖÉ\Ž6á
Éâ
d›6T
ª*dÓ6ë
ˆÃ|÷6[
Šˆœ£7b
ŒŠÒ´¸7i
½|Ð7ª
޳Š|²9

Õ$å9
ÃD:
Þ6dÑ3°
õÞ6±
õïAœÝ4Õ
ûïAÖ
û¡?´ƒ5®
üµ;L®5ñ
þ±‡9l¹5Ò
ÿ²ý@¤è5Ç
Ò”Gtþ5§
ƒ×º<\©6
Óö=œ¾6š
ÔœB¤á6Ù
ÔßüúDA This is a valid separator as `DataLocale` will never produce it.Á¿úÜà Mostly for internal useÁdé•|Ä‹5¤©”À'Ô”Üì°þ÷ÒÕüüLÿø··¤|¹ÈCØNwÐ#Á¶ Ú}®®¡?°Ç?±à?”Щþh)íøÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ´À
øÕ<¼™>¼Ü¤˜Ü€žÍìŒW ŒWÔVü¸ü¢$! Construct from a trie and valuesÁËú # SafetyÁüäOL The actual values contained in the trie must be valid indices into `values`ÁôÌÐË ç}ÔV
ŒWø_>¼s>üÿ6žÓÍ ãÍT‡ÔVü¹3žÓÍ ¾ãÍÔV7üóöùú ùÔV®®¡?°Ç?±à?”Щþh)íúÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙèf ƒ
ŒW$„Õ<™>¼¶<closure_kind>Á<closure_signature>Á<upvars>ÁŒW´å}ôäžÓÍ éãÍ®Wü­¤ü‰2/ Construct from a trie and references to valuesÁÀúÍÍüÙOãÍäÁÐË 
è}®W
ŒWø+?¼;?üû 9žÓÍ €!ãÍTƒ!®Wü¸!6ž!!ÓÍ ½!ãÍTÀ!®W"7"üõ!ø!ûü û®W®®¡?°Ç?±à?”Щþh)íüðÑ  …"
"ŒW$†"Õ<”"™>¼¸"Ÿ$"…Ò#Ò#ºÒ##"#ŒWãÓ ´±üî((üÑ'LI Optimized data stored as a single [`VarZeroSlice`] to reduce token countÁtù(ž%%ÓÍ ˆ)ãÍT‹)ãè}l°)
è}ÌüÒ)B„X‰d§Þ v¥Ö&'IKüñ*($ñ*$$ÐËüŸ+W4Ÿ+$$ ú€üû+¿ž))ÓÍ €,ãÍTƒ,üÙlÕ,‹Úü÷,B„X "üÀ-¤ž++ÓÍ Å-ãÍTÈ-üÙlÿ-‹Úü¡.B„X,"$üüë.$”Í”/údœ/ÍÍü­/OãÍô•0ÐËöÚ„X**
,ŒWøò?¼„@üÿ1¼ž..ÓÍ „2ãÍT‡2üÙlÖ2‹Úüø2B„X/7/(*üÂ3Å3ýþ ý„X®®¡?°Ç?±à?”Щþh)íþðÑ- Ò3-
/ŒW$Ó3Õ<á3™>¼…4ì5/…Ò0Ò0ºÒ00/0ŒWãÓ Ìø€ x{gjRUü¶3 ü“"  A backing store for baked dataÁ 5ž656Îìü¶â 9ûà Íì´Z Ê ´Z 5óàG‡á<óàS‡áH777ACüƒ Üð  Get the value for a keyÁ ÿ ÿûà®®¡?°Ç?±à?”Щþh)íÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙááâÉäˆ ’G†qA´Z5   5
7ûà´Z reqÁ¯ ™>¼Ô ´š 9„· 99óàœ· 9óàóà\×$üË:7 Traits for data providers that produce opaque buffers.Áß$±´¸1çÎ:;øò2æå:;ùƒ-å:;úÜ£äp:;ýìã
Ö:;Ѻå,â:;ÖÉáá:;Éûâ:;áT:;ª*àë:;ˆÃß[:;м,Œ7:;؈ùb:;ŒŠÒøi:;½÷ª:;޳Šö
:;Õõ:;Ãô:;ïAÅÕ:;ûïAÛÖ:;û¡?Å®:;üµ;Äñ:;þ±‡9ÃÒ:;ÿ²ý@ÂÇ:;Ò”GÁ§:;ƒ×º<À:;Óö=¿š:;ÔœB¾Ù:;tüò'ÎX=| <<ûËüý;üÄ.+ 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‡>>óàüý>bûàÎXü—!>óà+Ÿóà7Ÿ*ü½H¡@@Îì„Y Âb„YÎXüÅ!„YŒë‘YBüÁ6üƒ96 Returns an error if the buffer format is not enabled.Á|È ‘YÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ð]A ØA
B¤ä$üË>
; 📚 *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.Áüþc
` 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ì$ü¥(%
4ƒ(
(|•(
¶P Ë(
È.
 Ñ(
ä(
8BUFFERÁ4Ò(
$ Ø(
, Ú(
8·®$Û(
& ß(
8õ
$à(
*æ(
 é(
+
8¨4ó(
 ù(
 ú(
—+
7A version of [`ÁŒˆ)
$ ™)
8ÔL)
 ¤)
 ¥)
«)
, ¦)
8·®$§)
$ ¬)
7`] that uses custom data ÁÜ®)
$ É)
7%provided by a [`BufferProvider`].\n\nÁü×)'
$ þ)
71✨ *Enabled with the `serde` Cargo feature.*\n\nÁüŒ*3
$ ¿*
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
ÏW  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´€6
$ 6
, „6
 …6
6
+ †6
 ‡6
6
, ˆ6
8Ó‰6
& Œ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
, ‰7
 Š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Á„…8
$ •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ÀD¥9
& ­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
$ :
, „:
8šD…:
& :
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,€?
'…?
8ìT‡?
$ ?
, “?
 ”?
š?
, •?
8À$?

?
(ž?
8 4¡?
& §?
, ©?
8ÎLª?
$ ³?
, Á?
 Â?
Ê?
+ Ã?
 Ä?
É?
, Å?
8ÓÆ?

Ë?
8ÃLÙ?
& â?
 ä?
ë@
, ö?
8Ø,÷?
, ü?
 ý?
Š@
& þ?
, €@
8—ÇL@
- @
$ Œ@
, ž@
8ÒÇ4Ÿ@
$ ¥@
, ·@
8šD¸@
, Ñ@
 Ò@
Ü@
$ Ó@
, Õ@
84Ö@
- Ý@
% ö@
% ý@
 ƒA
¡B
 „A
A
8à?4…A
(A
8 4A
& A
, ˜A
8ÎL™A
& ¢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
& €B
8¼,B
, ‡B
 ˆB
˜B
$ ‰B
, B
84ŒB
& 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
8ìTõB
(C
8 4„C
& ŠC
, ŒC
8ÎLC
$ 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
, D
8ÒÇ4D
$ ˆD
, š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
, €E
8
options_tyÁTE
& E
8´ŒE
$ E

E
(“E
8 4E
& œ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
ˆF
$ ùE
, ûE
84üE
& F
8¼,ƒF
- ‰F
, 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ƒH
8 ‡H
, Š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
, €I
 I
I
$ I
, „I
8Þ\…I

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
& …J
, ‡J
8ÎLˆJ
$ J
, ŸJ
  J
¨J
+ ¡J
 ¢J
§J
, £J
8Ó¤J

©J
8ÃL·J
& ÀJ
 ÂJ
¿K

, ÔJ
8Ø,ÕJ
& ÚJ
8skipÁ$ÜJ
$ àJ
, òJ
8ÒÇ4óJ
$ ùJ
, K
8šDŒK
, ¥K
 ¦K
°K
$ §K
, ©K
84ªK
- ±K
% ÊK
% ÑK
 ×K
†M
 ØK
€L
, ÙK
 ÚK
ýK
 , ÛK
8Þ\ÜK
& çK
8¼,èK
& íK
, ïK
8ÆÞTðK
& úK
8´ûK
$ þK

ÿK
(L
8 4…L
& 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
…M
, ¹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
, €M
 M
ƒM
$ M
- „M
*ˆM
 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‰N
8 N
, N
8ÒÇ4N
 —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
, P
 P
P
$ ƒP
, …P
8Þ\†P

P
% ¥P
|ú$üË9 6 Utilities for using trait objects with `DataPayload`.Á<%Gimpl_casting_upcastÁœ„ JKimpl_dynamic_data_providerÁÔª0 LM#impl_iterable_dynamic_data_providerÁüô7# NOô± ü†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`].ÁŒ» GžHHGóàü± –á Í ´ZÄÝ Íìûà, ûàĉ GóàQŒû-û#óàcŒû?û5IIInpüD ü©S P Upcast a `DataPayload<T>` to a `DataPayload<S>` where `T` implements trait `S`.Á4„ ÎãááâÉäˆ ’G†qA–ûàGG
Iûà´Z¹
, üð " üÉ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Á(|È  nz Ò  À , š 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)Á (|· G€ ñ ñ/   ¸ ë , ¹ 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 ' 8”G $  8¨ã£ & ¦ , ¨ 8 '® 8º< $ » (Ë 8Í  Ô , æ 8 'ì 8ª*  ú , û 8¶„   $  ,  8,• 'š 8µ; $ ¥  ³  µ ¯& 8 8Ú  Ó 8Õ<Ô  Ö 8Ë0  Ý Þ  à ¡&  , ö  ÷ —! 
8³  8 8³  ˜ ,  8Ú  ¢ 8Õ<£  ¥ 8Ë0  ¬ ­ *¯  ² ! 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‡9lÜ% 'é% 8ó9të%  ù% 8Dú%  & Ž& 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,¤( '©( 8”Gt«( $ ¹( 8¨ãË( & Î( , Ð( 8,Ñ( 'Ö( 8º<\Ø( $ ã( (ó( 8Í4ö(  ü( , Ž) 8,) '”) 8ª*d)  ¢) , £) 8¶„,¤)  ©) $ ª) , ¼) 8,½) 'Â) 8µ;LÄ) $ Í)  Û)  Ý) Þ/ 8,ï) 8Ú4õ)  û) 8Õ<ü)  þ) 8Ë04ÿ)  …* †*  ˆ* Ð/ , ž*  Ÿ* â. , ¹*  º* Â* + »*  ¼* Á* , ½* 8â¾* - Ã* 8³ Ý* 8ß* 8³ â* ä*  ç* , è* 8‡…Dé* 8ò* , õ* 8,ö* 'û* 8å,Tý*  ‡+ 'ˆ+ 8÷,$Š+  Ž+ 8Õ<+  + 8Ë04+  ˜+ ™+ *+  ž+ Ì. 8¼+ 8 4À+ & Æ+ , È+ 8,É+ 'Î+ 8ª*dÐ+  Ü+ , Ý+ 8‡…DÞ+  æ+ è+ , Š, 8,, ', 8d, 'ž, 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‡9l/ '˜/ 8ó9tš/  ¨/ 8D©/  ±/ ½/ 8Ú4²/ $ ¸/ 8¨ãº/ % ï/ äŠ0 \üï02 4Í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 8”Gtõ2 (…3 8Í4ˆ3  Ž3 8¤,3 '”3 8 collectionsÁ\3 '¡3 8BTreeSetÁD£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Ë044  ‡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Ë04”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‡9lÏ6 'Ü6 8ó9tÞ6  ì6 8Ã\í6  ø6 ÿ6 8Ú4ù6 üË7% æ$Œí&lñ&T[bipÉæ‚PQæ‚ PQYokeableÁDôÙPR PPRÕPS©ï>PSö¸1îÎPSøò2íåPSùƒ-ìPSúÜìÑ
ÖPSѺå,ÐPSÖÉÏáPSÉéâPSª*µëPSˆ¼,¼nPSؽªPS޳Š
PSÃhPSÞ6g°PSõÞ6}±PSõïAgÕPSûïA}ÖPSû¡?g®PSüµ;fñPSþ±‡9eÒPSÿ²ý@dÇPSÒ”Gc§PSƒ×º<bPSÓö=ašPSÔœB`ÙPSÌÏÙ±ÌüÉFC A data provider that loads data for a specific [`DataMarkerInfo`].ÁTžUUTóàüÍ–á §¦áTóà)óà/VVV.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.Á$—ƒ ûàº<ƒÕ<Æ*W•¦6šƒÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ëëª*íÆ*îÖ*Å‹· {ä´Zð]T œT
Vûà´Z$¨ã£üß[8žX¡YXY–á äÎì­Z ç¦áT­Z´Z¨ZZVZ8:57üÏF ¨Zº<ƒÕ<Æ*W•¦6šèÌW ×W
Z8´Z­Z¨ãÞüù9üå
XU A data provider that can determine whether it can load a particular data identifier,Áü¾:7 potentially cheaper than actually performing the load.Á[ž\[\óàüùñTûà´Z–á ¦áT–[óà;¯Ò-óà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ˆ ûàº<ƒÕ<Æ*W•¦6šˆÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªeð][ ¤[
]ûà´Z¨ã«üìa8ž_¡`_`–á ñÛÎ ô¦á[­Z´Z”±¨Za]a0257üâOРЍZº<ƒÕ<Æ*W•¦6šÿÖ^ î^
a8´Z­Z¨ãõü£! ü =: A data provider that loads data for a specific data type.Á¿ úüà _\ Unlike [`DataProvider`], there may be multiple markers corresponding to the same data type.Áœ­!bžcbcóàü£!—–á Á!ýúŒÑ!bóà)óà/ddd.0üµ#ƒ
ŒWªtbù[¨øt¸bÍì¨ø ¸aÍìó[ »aãÍÔ‚bÓÍ ±aù[ü¦b!Íìù[´aÙ¨ø¤ÐbTó[ŒW|íb¸rsƒjlWY¤¦¡£Ôbü’cMT•cž ¸[º<ƒÕ<Æ*W•¦6šžÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ëëª*íÆ*îÖ*Å‹· {äù[ð]}  c}
ƒŒWù[¨øó[$¡c¨ã§cü¯d(d²dŸ Ÿ¸[¾l} ¿d}
ŒWù[¨øó[$Àdlˆ'ччâ‡â‡ó‡ó‡ˆˆˆˆ'ˆ'ˆL),†)ªñÒÜÖŒ°FdïŒÝ× `Œt<©{Œ©X>Œö¸1YÎŒøò2ZåŒùƒ-[ŒúÜ£\pŒýì]
֌Ѻå,^ŒÖÉ_áŒÉ{âŒcTŒª*d댈Ãe[ŒŠ¼,ˆŒŒØˆbŒŒŠÒƒiŒŠi
ŒÕjŒÃkŒÞ6l°ŒõÞ6±ŒõïApÕŒûïAˆÖŒû¡?t®Œüý@?njҔG@§Œƒ×º<AŒÓö=BšŒÔœBCÙŒB¤ç8*œü»ð]”Åcüá8ä ¡¢  ð] ¡ c cˆ¢cµ
 `£c `àB¤GS
¢Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBL è
± †\–˜üÉ*ü¬96 Converts this [`DataErrorKind`] into a [`DataError`].ÁêúüòDA If possible, you should attach context using a `with_` function.ÁTÖ†\ð]߇nBüÕCü‹74 Creates a [`DataError`] with a data marker context.Á\â†\¾lð]
úCÚDü™ GüÔ2/ Creates a [`DataError`] with a string context.Á„¦ †\ ð]
˜EÅŠEüê!.ü¢!52 Creates a [`DataError`] with a type name context.ÁŒñ!†\ð]¥ššÍìà_ ƒ"
à_$†"üŸ#LüÙ"30 Creates a [`DataError`] with a request context.ÁD¦#£†\¾lº<ƒÕ<Æ*W•¦6š£ð]\Ò#
$¯#Ú4µ#¨ãÍ#t§$ð]žŸ ¢£¥§ü¢%6ü¼$SP Returns a new, empty [`DataError`] with kind Custom and a string error message.Á4¯%öŠð]œœ
Ö;BFüä'>ü‰'HE Sets the data marker of a [`DataError`], returning a modified error.Á\ñ'ð]¾lð]œœ§ˆmGÚvGüµ*Bü×)KH Sets the string context of a [`DataError`], returning a modified error.Á„Â*ð]öŠð]œœ»Š±HÅŠ»Hüš-)ü¥,b_ Sets the string context of a [`DataError`] to the given type name, returning a modified error.ÁŒ¡-ð]ð]œ¥¡¡œ¦Œ ³-
 à_$¶-üœ1Kü/^[ 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£1¤ð]¾lº<ƒÕ<Æ*W•¦6š¤ð]œ\Ó1œ
¢$°1Ú4¶1¨ãÎ1üŽ:Püñ7A> Logs the data error with the given context, then return self.Á·8úü¿8RO This does not modify the error, but if the "logging" Cargo feature is enabled,Áü–9" it will print out the context.Á¤•:¥ð] ¥ð]œ¤¤ Ó:œÎìÓ™ ª:ÄcÓ™d­:
£Ó™$Ä:ÅŠ<Ê:-/üç=LüÊ;AÒ–<úü˜<R©—üï<"…˜”î=¦ð] ¦Ó™ð]œ¦¦ ¨>œ€š >¿cÓ™T„>
¥Ó™$™>ÅŠ<Ÿ>-/ü¯?(D½?ð]œ¥¨¨œ¦Œ Æ?
§à_ üA%ð]üÂC#ü’C/, 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ûàÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙƒžð]ªª
¬ûàƒž$ûDü¥E3¥®®¦Œ ªE’_¯¬¯üßECÔâE’_Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙà_ð]­­
¯à_$ýE,•)8ˆ8ˆJˆJˆ\ˆ\ˆ\Ê)<Î)ÇšÕÖ®q<ß³´µqµ´µ×ò `´p,†¿c´·pÂc´·Ž$še´¸Ž e´¸r,²é!´¹ìT‡
Öº´ÐµLì“„û…„‘c„§AÜö1ü€0
 `£c `àB¤GS
ªë…» ¾»
¼8$¿± Åü¬#Á¾¾b¿ÀÁ±ü¢1üÖGD Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataLocale`].ÁT© Á
Ö
Öì
×languageÁ
ØscriptÁ
ÙregionÁ
ÚvariantÁ
Û subdivisionÁà³ MýçÐØb½½
¿Áà?4´ü…Qü¯QN Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataMarkerAttributes`].Á¬Œ Áêcb½½
ÀÁÇ?Œ¢ü¦ü½da Creates a [`DataIdentifierBorrowed`] for a borrowed [`DataMarkerAttributes`] and [`DataLocale`].Áü­ Õª¸¨b½½
ÁÁÇ?Œ×à?4ŒüÜ=&8««Ùdôä‰><Œ>ÙdÂÂ
Ã8üÏ>#êcÅÆê!ë!Æ\ù>4þ>ÄÄüž? ,¡?¬ ¬êc ¬êcê!Ä §?Ä
Æ$¨?üÞ?#êcÈÀcÈü–@8™@­®¯ ­êc ® c cˆ¢cµ
 `£c `àB¤GS
¯ë…Ç @Ç
È$ž@± ¤@ÌÎAêcÊËÌÍÎÏü®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± ±Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ±êcýdÉ ñ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 units other than `[a-zA-Z0-9_\-]`.ÁlÓK² ²Ú}Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ²êcýdÉ íKÉÑŸ“¥*Rü…U0üãSG¥°¯Túü·TIF Panics if the string contains characters other than `[a-zA-Z0-9_\-]`.ÁŒ’U³ ³ ³êcÉ §UÉ
;2Tü W%üíV.+ Creates an empty [`DataMarkerAttributes`].Á,­W êcÉÉ
ÎüüX"üÁX63 Returns this [`DataMarkerAttributes`] as a `&str`.Á4‰Y´ ´êc ´É YÉ
Ï$Y<ß)ŽˆŽˆ ˆ ˆ²ˆ²ˆ­*d²*D¶*áâåæêòûëæçÙÞ6dÛ°Ö×Þ6±Ö×µ;LôñÖØ±ì
ÖÖÙѺ¼,Œ¡ÖÚØp,ô¿cÖÛpÂcÖÛæ‚\ÖÜæ‚ÖÜ€‡¬âÖÝ cartable_ptrÁeÜÖÞeitherÁ5ò2ÖÞÂÙÖÞ PÖÞ
CloneableCartÁmðïÖÞà %ÿŒÖÞÄÏ„íaŒƒNÄš8„é'ÌÿüÎ)á$ýÌç ªeàü¢
1´‡
 Sets the checksum.Ál©
ªeªeßß
à
ÕBD½
ü± @= 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);Á£žžããÓÍ ÜŒWŒßèf’G†qA–âäÙ®èf]Ù®èfáá
âŒWvxôòááÙ®Sü”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:ÁŽ!ú<’!£žüš!!´žü¼!$ÄÔá!úüå!(% 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
è}€‡Ï8Œ©‡H_}öáf@ Ù®ðñ¸ÕÙ®ÌÎõ‚õ‚êê
íŒWõ‚õ‚íæÙ®êê«èü¯)5êêíæçƒçƒêê
ðŒWçƒçƒ¸ÕÙ®êêŸé´õ)êê¸Õü‘*;”¡*žó ôôóÓÍ ´*ßä Ê*ÆÐŒ·*ކê‹ÁAžD:6õöøùö÷íæކùúÆŠކY[^`7„7„òò
öŒW×g7„7„íæކòò¾ëüØ*5òòíæ‹„‹„òò
ùŒW×g‹„‹„ÆŠކòò¶ììš+òòÆŠü½+@¼Í+žü ýýüÓÍ å+ßä û+ÆÐŒè+ÆŠ|Ìô9
¸þÿÿ¸ÕÆŠƒ×gÆŠXZ]_-…-…ûû
ÿŒW×g-…-…¸ÕÆŠûûØî´Ž,ûû¸Õ€…€…ûû
ŒW×g€…€…×gÆŠûûÏï ±,ûû×gÌ®0»¤Œ™0œ˜0ô0L¾0æçüž1"fLè3›f‡üÌ9‚\Ú9ŒŒà À†Ô†  †|À§M
¶iÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ›fŒŒà À†Ô†  †|À§M
¶iÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙæçªˆˆÍì¶i æ9Ù¶idÁ:
¶iÕ$é913º:lž<…ÒŠÒŠºÒŠŠŠ¶iàñÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ̈4¼<…ÒÒºÒ¶i›f̈ü×<€žÓÍ Ü<ÆÐŒ…=Ž¿c Žè}ŽÛ,Ñ=èfÀcHJ =üÞ=Dá=µ· µèf  c cˆ¢cµ
 `£c `àB¤GS
·ë…Œ å=Œ
ŒW$æ=± ì=üÈ>–ž ÓÍ Í>ßä Ð>ÆÐŒþ>¿c è}Û,Ê?¿c×g,Ø?£g”Àc_adf™?üå?Dè?¸¹º ¸£g ¹ c cˆ¢cµ
 `£c `àB¤GS
ºë… ì?
ŒW×g$í?± ó?Ð@…ÒÒºÒŒW×g è}Ûë…  c cˆ¢cµ
 `£c `àB¤GS
ƒA…ÒÒºÒŒW×g ×gë…ËüüÜC|ü¢A=: Cloning a [`DataPayload`] is generally a cheap operation.ÁüàA/, See notes in the `Clone` impl for [`Yoke`].ÁBút”Báð£Búl§B
```no_runÁüµB%òñüÛB!´žýBúüC30 let resp1: DataPayload<HelloWorldV1> = todo!();ÁôµC let resp2 = resp1.clone();Á<ÔC£žž˜˜ÓÍ áCÆÐŒŠDØè}Û,ÒDèfšÙš>@¥D¼ßD,âD» »èfèf èD
šŒW$éDüËF’žœ œÓÍ ÐFßä ÓFÆÐŒGžØè}žÛ,ÉGØ×g,×G£gŸÙŸUWZ\œG¼äG,çG¼ ¼£g£g íG
ŸŒW×g$îGüèK„ž¡¡ÓÍ íKÆÐŒšL¢µßè}¢ÛÖ„LâLèf£·ß£DFµLüóL"öL½¾ ½èf ¾èf  ùL 
£ŒW$úL¹
,€MüÂM—ž¥ ¦¥¦ÓÍ ÇMßä ÊMÆÐŒüM§µßè}§ÛÖ†LÄN×gÖN£g¨·ß¨[]`b—NüàN"ãN¿À ¿£g À£g¤ æN¤
¨ŒW×g$çN¹
,íNü¨PvžªªÓÍ ­PÆÐŒÓP«è}«Û›Qèf35îPü¤Q‰ž­ ®­®ÓÍ ©Qßä ¬QÆÐŒ×Q¯è}¯ÛŸRò†ªR£gCEHJòQüÙW6ž±±ÓÍ ÞWÆÐŒýWèf²³´¸º»¿ÄÉÏÑÓÕ68üá\.ü–XIF Convert a fully owned (`'static`) data struct into a [`DataPayload`].ÁäXúüìX0- This constructor creates `'static` payloads.Á¡Yút©Yáð¼Yú<ÄY£žüÐY%òñüúY!´žÌ Z®ò¾ZúüÆZ# let local_struct = HelloWorld {ÁüîZ2/ message: Cow::Owned("example".to_owned()),Á4¥[à°[úü¸[PM let payload = DataPayload::<HelloWorldV1>::from_owned(local_struct.clone());Á\úü•\-* assert_eq!(payload.get(), &local_struct);Á<Ç\£žTè\è}èf°°
²ŒW·®$ó\ü_Bü“^85 Construct a [`DataPayload`] from a static reference.ÁÐ^úüØ^$! This is mainly used by databake.Á|œ_¸Õèf°°
³ŒW·®ÓVüåhÍü`63 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);Á<ôd£ž€eúüˆeSP To transfer data from the context into the data struct, use the `move` keyword:Áàeú<èe£žüôe0‹“ü©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 Áèf°Áµµ°ÍìÙ™ ùhÙ™<¥i·"Ù™ ·è}ÁÛü¯i?·Ù™ºš˜"ü·i7
è}è}ü‡j*
´ŒWÁÙ™$„i± Šiõh˜š³iüÕqGüÃm  Borrows the underlying data.Áèmúüðm_\ This function should be used like [`Deref`] would normally be used. For more information onÁüÔnIF 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¹ ¹èf ¹è}¹Û°àq°
¸ŒW$è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Á ÁèfÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ è}Û° ¼u°
ºŒW$½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()`].Áøyúü€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());Á<¬…£ž\¿…èfÙ™ááâÉäˆ G†qA&°&¼½¼½°ÍìÓ²Ë…Žš Ï…Ó²Œ‡†¾–"Ù™è}¾Ûæ‚Fu\»Ÿ ¾ü¥†¾Ù™ij˜"Ó²¾Ûü˜‡(øšüÙ‡*
»ŒWÓ²Ù™$Ò…± Ø…ßáã婆üÕ’¥üæŠ[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×®êúüò4
ü¬£<9 obj.message.to_mut().push_str(string_to_append);ÁÜí£ Ok(obj.message)Ád¤ })?;Áž¤úü¦¤-* assert_eq!("Hello WorldExtra", p2.get());Áüؤ  # Ok::<(), &'static str>(())Á<ý¤£ž|¥èfÙ™Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¢²°‚&ÅÆÇÆÅǰˆ³ ¥Žš ¤¥ÍìÑÈ §¥£³Œê¥È–"Ù™è}ÈÛæ‚Fu\»Ÿ Èüˆ¦¦ÈÙ™Òɘ"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«´ÈÛÑÈüû¦3øšüǧ*
ÄŒWÓ²Ù™ÑÈ$ª¥± °¥8;>A;>Œ¦üÙµÂüݪ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());Áüö´-öÅü¨µ ®Æ<͵£ž´àµ½™½Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ž½°¶&Ê&ËÌÍÍËÌʰ‘¾þµ£¾ ‚¶Íì«Ô …¶µ¾ŒÏ¶Î–"™½ ¶&è}ÎÛæ‚Fu\»Ÿ Îüí¶­Î™½¹Õ˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ä¿ÎÛ«Ôüç·3
ÉŒW¶&Ͻ™½«Ô$± •¶,÷µBEHKEHñ¶üíÄ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();Á<ÓÄ£ž$ôÄèf¢²°‚&Ðаˆ³ùÄ£³ü¬Å-Ó²è}Ô¾Å
ÏŒWÓ²$ýÄ68ü³Êsü²ÇW‡×üŽÈ$é×·Èúü¿ÈS¥Ø—ÉúüŸÉ`Ùä„ÊúÙDºÊ Âèf ¢²°‚&ÒÒ Çʰˆ³ÃÊ£³üøÊ-‰àÔŠË
ÑŒWÓ²$ÈÊ,.üùÞ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(
ûËàñÂ…××
ØÕ$‡ùü û8üÖúEB Converts a static byte buffer into a `DataPayload<BufferMarker>`.Á”§ûûËÂ…××
ÙÒÇ4ºûüÜü^žÛÛÓÍ áüÆÐŒŒý³è}<²ýèfÜ´Ü,.¤Áý<ÄýèfÚÚ
ÜŒWüŽþ>žÞ ßÞßÓÍ “þßä –þÆÐŒºþ£gàáâãå)+-/üÿ4üÓþ74 Creates a [`DataPayloadOr`] from a [`DataPayload`].Ád¤ÿèf£gÝÝ
àŒW×gÖ*<±ÿüµ‚#üê85 Creates a [`DataPayloadOr`] from the other type `O`.ÁT¼‚×g£gÝÝ
áŒW×g¹
,Ç‚üœ„ ü̃=: Returns whether this object represents a [`DataPayload`].ÁT£„Ä Ä£gÝ ®„Ý
âŒW×g$¯„ü©‡VüƆPM Gets the value from this [`DataPayload`] as `Ok` or the other type as `Err`.Á°‡ä ä£gÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 äè}äÛ ä×gÝ´‡Ý
ãŒW×g$¼‡üÌ‹4üÍŠA> Consumes this [`DataPayloadOr`], returning either the wrappedÁü“‹&# [`DataPayload`] or the other type.ÁTÓ‹£gÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
èf×gÝÝ
åŒW×g$Þ‹üþŽ<žççÓÍ ƒÆÐŒ¨ååæñéˆ v˜ Á,|}QŒWèéKM¬•üÁA> Convenience function to return the other type with value `()`Á$œµ“ææ
èŒWü¯‘VüÕGD Convenience function to return `Some` or `None` for other type `()`ÁT¶‘ê 굓ۼݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ êè}êÛæÁ‘æ
éŒW$ɑԲ“ü©’LI A response object containing an object as payload and metadata about it.Ád½“žììÓÍ Ê“ÆÐŒÚ“²hÅ‹· {äíî)+üŸ”"üó“'$ Metadata about the returned object.ÁD£”ëëªeÜ┬Ȕ The object itselfÁ<æ”ëëèfü‚•7žððÓÍ ‡•ÆÐŒ§•²hñóü”™nüÀ•W‡×üœ–$é×Å–úüÍ–S¥Ø¥—úü­—`Ùä’˜úÙ³˜úü»˜FC For runtime dynamic casting, use [`DataResponse::dynamic_cast()`].Á$›™²hëëª*íÆ*îÖ*Å‹· {äÓ²ï‚&òò ™£³üÔ™-‰àÔæ™
ñŒWÓ²$¤™,.üømü„›RO Convert a [`DataResponse`] to one of the same type with runtime type checking.ÁÛ›úüã›I¾â±œúü¹œ]Ÿãúü£B? For compile-time static casting, use [`DataResponse::cast()`].Ádÿ²hÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
…œð]ï‚&ôôŒž£³ŒÓž
óŒWÓ²$ž"$üòŸžööÓÍ ÷ŸÆÐŒ¡ ÷¿c ÷è}÷Û,í ²høÀcøKM¼ üú Dý ÅÆÇ Ųh Æ c cˆ¢cµ
 `£c `àB¤GS
Çë…õ ¡õ
øŒW$‚¡± ˆ¡ü—¥}üÛ¢>; Cloning a [`DataResponse`] is generally a cheap operation.Áüš£/ÒýÊ£útΣáðÝ£úlᣯþüï£%òñü•¤!´ž·¤úü»¤41 let resp1: DataResponse<HelloWorldV1> = todo!();Áôð¤ªÿ<¥£žžúúÓÍ œ¥ÆÐŒÆ¥ûØè}ûÛ,ަ²hüÙüAC᥼›¦,ž¦È Ȳh²hù ¤¦ù
üŒW$¥¦¼‰+ĈDª+êˆêˆüˆüˆ"‰"‰4‰4‰|„,\ˆ,®§ùúµíîÑK¤á냛J´÷Õƒµ;Lœñƒˆ±‡9l§Òƒ²ì
ÖƒŠÑºTƒ¡8´ÐɃŒˆ×ó `ƒæ‚ƒŽæ‚ƒŽLocalePreferencesÁŒ¹
ƃÂك Pƒimpl_data_provider_never_markerÁüõ5¨©°
ôƒtuplevarÁEÞ
øƒvartupleÁEð
ƒ¿/ä

°ƒAsULEÁ-¦4

µƒEqULEÁ-ÝA

¹ƒ
SliceAsULEÁUƒC

ºƒ
5Öd

¿ƒUleErrorÁE›‡

óƒCharULEÁ=‰

²
ƒÞ 

¯ƒMultiFieldsULEÁu

Ì
ƒ
NicheBytesÁU¡

ƒ NichedOptionÁe­

à
ƒ™¬
á
ƒNichedOptionULEÁ}»

ƒ OptionULEÁMÞ

Óƒ OptionVarULEÁeé

òƒ RawBytesULEÁ]‡

ƒ·­
ƒ¿/ºƒ
 ·ƒ
5Π
 ¸ƒßâÐÓ,”ÅȲµž¡ŠuxfÌüWü›/#ü‘$üö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`].Áþúü‚gd 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).Á¡úáð´úü¸B? 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.Á$½¾lüˆ+üÖ1. Extension trait for methods on [`DataMarker`]ÁlŒûûàŒû(ÇŒû4Çš˜š˜šüöcüº74 Binds a [`DataMarker`] to a provider supporting it.Á$ù¬[ÉÉ¡8ÌÏ8PÍÜ8P< ý”¿-ûà¬[¡æõ þT¬[ûà”Æ
˜ûà¬[ûæD+-ü·8üÞTQ Constructs a [`DataLocale`] using fallback preferences from this [`DataMarker`].Á\º
Æ
Ƭ¨
ÇÒ§

Èã§

Éò§

ʨ

Ëregion_overrideÁ
J…²s$Ø+¾¨
šûàà?4Æüó/žœœÓÍãÍŒWŸ˜šŸ øü©c¬[ñZ¡žžæõ ±þõ”ù
ŒW¬[ûæD´ "üÌ7Öʾ¨
ŸŒWà?4Ûüç&Oª¡¡Ïó ì&¢Ù¶i¢d©'„i£+-¢'|½'TÂ'  ¶iüÕ'Hª¥¥Ïó Ú'¦Ù¶i¦d(„i§+-‰(Ô¤($ª(¤¤¾lü«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è/êÖ<ó/ ));Á<û/£ž4‰0(|0F‰ Ú0 ·5 à0 é0, á08´â0& ä08õ
$å0*ë0 î0 ´5)8$ø0 ü08ª ý0 þ0, €18,1'†18dˆ1 ”1, •18,1'18Ú41'£18ÐC\¥1 °18ª ±1²18
µ1, ¹18´º18$,Å18
×1 Ú1:ÁÛ1 Ý18ª ß1& à1, â18,ã1'è18¥ <ê1'ñ18Õ$ó1'÷18ÂDù1 2:Á2 „2$ …2 2 ®58 28¬$ 2 ¤2 ó2
 ¶28$·2$ »28¨ãÍ2& Ð2, Ò28,Ó2'Ø28º<\Ú2$ å2(õ28Í4ø2 þ2, ÿ28,€3'…38ª*d‡3 “3, ”38,•3'š38Ú4œ3'¢38ÐC\¤3 ¯38ª °3±3$ ³3, µ38,¶3'»38µ;L½3 Æ3 Ô3 ¤58æ3 é3 5 , ê38,ë3'ð38‡9lò3'ÿ38ó9t4 48D4 ˜4 •5 ®4, ¯48,°4'µ48Ú4·4'½48ÐC\¿4 Ê48ª Ë4 Ì48Î4, Ñ48,Ò4'×48å,TÙ4 ã4'ä48÷,$æ4$ ê48¨ã€5$ ƒ5% µ5üÐ5!¹¬ï8ëi«¬äÍ9ü‹9=: Magic bytes to locate [`DataMarkerIdHash`]es in binaries.Á\×9ªªûËü§:&üú9(% Gets the hash value as a byte array.ÁD´:ëi›³ªª
¬E[ Ë:üþB'L‡CƒÉ ÉÚ} ˜Cçê¼Ó7gü±H6dºHƒ»Á§$ËHùÓskŒòH4øHƒŒ‘I4—IƒüÍQëi³´µ

·
¸µ´DóQøQ²²ëiü–R"d™Rëiëi
²²
´$¦RüàR/tãRþãëi²²
µ unalignedÁLòRüÓS&ëiü„W¥k¸·ß¸ü¸W"»WÊË Ê¥k Ë¥k· ¾W·
¸$¿W¹
,ÅW̆X¥kº»ºü´X2·XÌÍ Ì¥k Í¥k¿ßÀßÁßLessÁÂßÃßÄß~Å߯ßÇßGreaterÁÈßåºÝÈnûê7¹ »X¹
º$¼X¹
,ÂXü•Y ¥k¼ïß¼üÊYB\ÍYÎÏ Î¥k Ï¥kÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙçæ» ÙY»
¼$ÚY¹
,àYü¶Z&¥k¾e¾üñZ4$ôZÐÑ Ð¥k ѽ¿¿ [½Íìžê ùZ¢ežê”üZ
¾žê$‘[º,—[,.ŒÏ[¥kÁÂüÉ]Q4í[LÖ]öŠÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥köŠÀÀ
ÁÐ “züŠg-üƒd;8 Gets a platform-independent hash of a [`DataMarkerId`].ÁÃdúüËd74 The hash is 4 bytes and allows for fast comparison.Á‡eú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¥këiÀÀ
Âü¬s"¾lÄïßÄüÕsB\ØsÒÓ Ò¾l Ó¾lÑèà äsÃ
Ä$ås¹
,ësÜÁt¾lÆ»Æüãt2ætÔÕ Ô¾l Õ¾lçæÅ êtÅ
Æ$ët¹
,ñtüÀu(¾lÈeÈüïu4$òuÖ× Ö¾l מêÇÉÉ ŽvÇËê ÷uÜê”úu
Èžê$vº,•v$&œËv¾lËÌÍü†w.äåv See [`Default::default`]Á<“w¥k¾lÊÊá°Õ<f€üª‚@ü„zVS 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”ÕÍÕT‚€êÖ<‘€ñÕúü¥€/, // The error context contains the argument:Á|Ù€ÚóÔí€ HelloWorldV1::INFOÁüŒ(% .match_marker(DummyV1::INFO)Á̹ .unwrap_err()Á¤× .marker,Áôð Some(DummyV1::INFO.id)Á4“‚‡ú<ž‚£žd±‚¾l¾l­ƒÊÊ
Ì$¾‚Ú4Ä‚üÆ„Aü…„<9 Constructs a [`DataLocale`] for this [`DataMarkerInfo`].Á\Í„¾lÖʾ¨ÊÊ
Í$Ù„à?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);Á<Š£ž(|‰ŠW‰ ÖŠ ☠܊ Ú‹, ÝŠ ÞŠ ëŠ+ ߊ àŠ êŠ, áŠ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'×8”G è ê Ϙ, ü ý < ```rustÁ\“Ž+ ³Ž ´Ž îŽ8ÓµŽ ¹Ž8¨4»Ž ÁŽ ÂŽ íŽ7let ident = \"Á„ÃŽ$ ÓŽ8ÔLÕŽ ÞŽ ߎ åŽ, àŽ8Ð $áŽ$ æŽ7\";Á,èŽ+   ´8Ó Š8¨   ³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«,È“ Í“ ד8LΓ84î“8 DebugTestÁLõ“% þ“- ‘”+ £” ¤” ¶”8«,¥” ª” µ”8
unused_mutÁT«”8…•8‰•8infoÁ$ ’•8,”• š• °—, œ•8,'¢•8”Gt¤•'²•81<´• »• ¯— 8,Ò•, Ø•8,Ù•'Þ•8Ú4à•'æ•8°Fdè•'ô•8º0Lö• ÿ• ‘–8ÔL€– ‰– Š– , ‹–8Ð $Œ– “– ®— 8«­– ¯– ´–8õ
$°–*¶–8õ
$¹–$ ½–8×– Ú– Ü–8 Û–*Þ–8Á
,á– æ– ç– ›—8¨4è– î– ï– š—7Invalid marker name: Á¼ð–$ ‡—8ÔL‰— ’— “— ™—, ”—8Ð $•—$ œ—% ±—, × Ä— «˜, Ú— Û— ä—+ Ü— Ý— ã—, Þ—8û$ß—
å— û— ™˜8Ž’$ü— €˜, ˜8¬…T‚˜ ˜, ˜8æ…D˜% ˜˜
¬˜8Ž’$¾˜% Иüå˜"¾lÐÀcÐüŽ™4‘™ØÙÚ Ø¾l Ù c cˆ¢cµ
 `£c `àB¤GS
Úë…Ï •™Ï
Ð$–™± œ™üÍœU˜ÒÒÍì nTÒœÓÙ nÓ¤ÞœîmÔ-/âœÑÑ n\ž,h‰h‰z‰z‰Œ‰Œ‰tÜ,üñ,96 Additional [`DataMarker`](super::DataMarker) helpers.Á4ä,ü¨üß-¨Ú©ƒ-lª.ܰFd¹.ݯD„Ç.ùÞ§HdÙ.µßÐC\ç.íàüË-3t”Œ.bdTVFH8:*,Œþ.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.Áããóàüʳãóàóà ääÎìûàäü×$
¿Õ¤ͤæ¤ü×#üè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`].Á(|Ýž‰ ª Ý  ° í ±, ²8genericÁ& º8¼& À, Â8boundÁ& È8¯É Ë, Í8´Î& Ð8õ
, Ö × ë$ Ø, Ú Û é+ Ü Ý è, Þ8& ã8û
ê- ì*ï ò '8 , 8¤¦<& , 8Ö¦ , 8,”'8Ð3'ž8È2l 8
®, ²8´³  ç8!8Ý2 × Ù Ü Ú Û% Ý, ñ ò ÿ, ó ô ý+ õ ö ü, ÷8
þ- 8 Ž, 8¤¦<& , 8Ö¦ Ÿ, ¡8'§8Ð3©'¬8Ý œ®8
Â, Æ8´Ç Ê 8!8EncodeableStructÁ„Ý í:Ã%î ð ò ô:Ã%õ ø û ù ú8$8& :Ã%% 8 8maybe_as_encodeableÁœœ ¯:Ã%° ² ³ ¼ ´:Ã%µ8$¸(¾8¬ Ç8'Ì8•¬„Î Þ:Ã%ßá ä 8©% ˜ ž ¿, Ÿ8´ & ¢8õ
, ¨ © ½$ ª, ¬ ­ »+ ® ¯ º, °8& µ8û
¼- ¾*Á Ä Å8, Ó8'Ù8Ð3Û'Þ8È28
î, ò8´ó ö §8!$„8Ý2l‰   œ š % , ± ² ¿, ³ ´ ½+ µ  ¼, ·8$¸
¾- À8, Ï8'Õ8Ð3×'Ú8Ý œÜ8
ð, ô8´õ ø ¿8!$†8•¬„‹ :Ã%œ ž   ¢:Ã%£ ¦ © § ¨8$8& µ:Ã%·% ¹8 Ç8³­œÊ Ý:Ã%Þ à á ê â:Ã%ã8(ì8¬ õ8'ú8•¬„ü Œ:Ã%  µ8©% Æ Ì É, Ö8´×& Ù8´Ú$ Ü8varuleÁ& ì, î8±¶& õ8´ö$ ø,  ƒ +   , 8$‡& 8û
8encode_as_varuleÁ„œ& ¬, ®8È·„¯& ¿8*Ë Î Ú8 Ü:'dataÁ â, ä8'ê8Ð3ì'ï8È28
ÿ, ƒ8´  »8!$•8Ý2 ¨, ª8±¶% ±, Å Æ Ï+ Ç È Î, É8
Ð8 Þ:´¸ ä, æ8'ì8Ð3î'ñ8Ý œó8
, 8´Œ  Ô8!$8•¬„¢ ²:Ã%³ µ · ¹:Ã%º, ½8±¶8$8& Ï:Ã%Ñ% Ó8 á8³­œä ÷:Ã%ø ú û  ü:Ã%ý8$€(8¬4‰ 8$'8•¬„– ¦:Ã%§© ¬ Ê8 ¥8bind_lifetimesÁ 8 · ¸ ¹ ¾8± º& »8 ½(À8 Ã8$8 Ë& Ì8
Î Ñ:´¸ ×8Ù Û æ Ü:´¸, ã8´ä(è ë:´¸, ò8±¶ ú þ8± ü8Û$  ¼8è½t• £ µ, ¤8È·„¥  »8% ÛüØ&0¥çŸèç覌 Ý&Ÿtà&ønêä æ&'l”'ææ
Ôµ)ˆoìä”Ö)lÛ)ëëïÂüæ+IÁî§ïïîÎìÜo ï+
¿Üo4ò+’oðäë+#%”¶,l»,ííÜo\/ü£/IF Traits that data provider implementations can use to optimize storageÁüñ/.+ by using [`VarULE`](zerovec::ule::VarULE).Á¤0úü¬0&# See [`MaybeAsVarULE`] for details.Á™/È2lö0ãòüà0#|¥2üÞ1FC Core selection of APIs and structures for the ICU4X data provider.Á<­2Þ6°õÞ6±õ©>ö¸1Îøò2”¡åùƒ-­¡úÜïAÕûïAÖû¡?£®ü£È¡pýµ;¦£ñþ±‡9Á£Òÿ²ìã¡
ÖѺå,¢Öý@Ü£ÇÒ”G÷£§ƒ×É¢áÉ¢âTº<¤Óö=šÔª*눜BÙÈ¢[м,€³Øˆ¢¢bŒŠÒ¼¢i½Ö¢ªŽ³Šñ¢
գãTÄ3e¡,’4”¡”¡¬½4­¡äÔ4a£üú4£È¡È¡¦£¦£Á£Á£ã¡ã¡¢¢Ü£Ü£÷£÷£¢¢¤¤ˆ¢ˆ¢€³€³¢¢¢¢¼¢¼¢Ö¢Ö¢ñ¢ñ¢££££„µ:üË) & 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`.Á4 :D½:ëÕÜ…
éo”ôß
ü§
3 0 Const-friendly version of [`Default::default`].Á<ì
éoý‚ü  ' éo´¤Î éo
̹! ™q˜ôˆ" üÙ!* ' Const version of [`Default::default`].Á<•" ™që€ü„#% ™qš´š¤°# <³# ™q
š\ˆ?»¡œ‡>¬†>„©>»¤Œ»>úŒ
”Ò>¤Ñ>ü¨>?ü¤>Düý=müô=x4ó>?ô,@œÕ$Í@œžŽ’$ü@œŸ,«Aœ traceÁ,ÛAœ¡ü®?(|š?®‰ Î? ò? Ø? å?, Ù? Ú? â?, Û?8¿ Ü?& Ý?8$Þ?$ ã?
ä?*ç? ê? ë?% ì?Ì€@ó̰@åÌß@ÖÌŽAÈ̾Aµô³üá@= Regular baked data: a trie for lookups and a slice of valuesÁž££ÓÍ ÃãÍÔV¢{rì¼ØÞ¤¥')ü­($­¢¢ÐËüÛ ¢¢ÏÏ(«-ž§§ÓÍ¿cŒWÃãÍ ¿cè}IÔV¨Àc¨ÅÇfhÛÜÝ ÛÔV Ü c cˆ¢cµ
 `£c `àB¤GS
Ýë…¦«¦
¨ŒW ±ü‹!ü¹@ÿÔ<–žªªÓÍ žãÍ®Wߘ½—àYn«¬')üˆ(©©ÐËü¶)©©µÕ(ƒ.ž®®ÓÍöמãÍŒØ;®W¯Àc¯·¹XZÞßà Þ®W ß c cˆ¢cµ
 `£c `àB¤GS
àë…­ƒ­
¯ŒWþ±¼Øü÷JG [`DynamicDataMarker`] for raw buffers. Returned by [`BufferProvider`].ÁÂúüÆFC The data is expected to be deserialized before it can be used; seeÁü'$ [`DataPayload::into_deserialized`].Á9ŒµÎX‚º'M¾,¢^±)°°ÎX(Ð/ÎX³Àc³!#áâã áÎX â c cˆ¢cµ
 `£c `àB¤GS
ã녲в
³Ã±ɬÙüŠ85 An enum expressing all Serde formats known to ICU4X.Á9ŒÇ‘Y§ƒk±ùyoµ·¸¹º¸ºüõVS Serialize using JavaScript Object Notation (JSON), using the [`serde_json`] crate.Áf´´‘Yy{´´‘YD”üÚ52 Serialize using the [`bincode`] crate, version 1.ÁE´´‘YXZ´´‘YLÝü¢63 Serialize using the [`postcard`] crate, version 1.ÁF´´‘YY[´´‘Y(Ì0Àc¼!#äåæ ä‘Y å c cˆ¢cµ
 `£c `àB¤GS
æë…»Ì»
¼Ã±ÉHÓ1‘Y1‘Y¿·ß¿57çè ç‘Y è‘Y¾Ó¾
¿¹
Þ2‘YÁÁ!'<é é‘YÀÞÀ
Áâ3‘YÃeÃ!#êë ê‘Y ëùÂùÄÄâÂÍìê¢eê£
Ã걺·¹» è4Y(î
5Y/35ÙÈMOì ì‘Y‘YÇîÇ
Șü^'ü¨]96 A [`DataProvider`] associated with a specific marker.Áâ]úüæ]%" Implements [`BoundDataProvider`].Á´¨^žÊ¡ËÊËÓÍ ¿^æõ Â^ñZ< ý”¿-ÌÍ'),.DË^,Ë^PÉɬ[¼Ù^<Ù^PÉÉ؃(•^6žÏ¡ÐÏÐÓÍ«æõ©ö׿^¿c¬[Â^ñZÑÀcÑÚÜßá~íîï íñZ î c cˆ¢cµ
 `£c `àB¤GS
ïë…Ε^Î
ÑŒW¬[(±/´Äü³@= A list specifying general categories of data provider error.ÁôúüøNK Errors may be caused either by a malformed request or by the data providerÁüÇ41 not being able to fulfill a well-formed request.Á9Œ²†\»ú?„ÌZáâãäåæçèêëíîïðâäæèé¾l†\ëìöІ\îð(
7†\/37†\ÕÙÕMOð ð†\†\ÔÔ
Õ˜ Œ8†\9†\ØØ!'<ñ ñ†\××
Ø…H –:†\:†\Û·ßÛ57òó ò†\ ó†\ÚÚ
Û¹
8"¡Œ;†\ÞÅcÞ.0ôõö ô†\ õ c cˆ¢cµ
 `£c `àB¤GS
öë…ÝÝ
ÞÐ formatterÁß(2ª<†\àÀcà!#÷øù ÷†\ ø c cˆ¢cµ
 `£c `àB¤GS
ùë…ßß
àñÉtïüá\Y No data for the requested data marker. This is only returned by [`DynamicDataProvider`].Á=lÒÒ†\ÒÒ†\”ü„SP There is data for the data marker, but not for this particular data identifier.Á>cÒÒ†\vxÒÒ†\t²ü¦b_ The request is invalid, such as a request for a singleton marker containing a data identifier.Á?rÒÒ†\ÒÒ†\iüÇ74 The data for two [`DataMarker`]s is not consistent.Á@iÒÒ
èii¾l†\ÒÒÌÿt“
ÒÒ¾lµü©
@= An error occured during [`Any`](core::any::Any) downcasting.ÁAµÒÒ
ëµµöІ\ÒÒÿ€ dª ÒÒöŠ ü¾ 63 An error occured during [`serde`] deserialization.Áù úü 63 Check debug logs for potentially more information.ÁBÒÒ†\¥§ÒÒ†\4õ
üï " An unspecified error occurred.Á
úüž
6® CLÒÒ†\_aÒÒ†\¤Óü–63 The error type for ICU4X data provider operations.ÁÍúüÑa^ To create one of these, either start with a [`DataErrorKind`] or use [`DataError::custom()`].Á³úˆíÅúüÉ_\ Create a [`DataErrorKind::IdentifierNotFound`] error and attach a data request for context:Á©ú¯þü»#†·üß2/ let marker: DataMarkerInfo = unimplemented!();Áü’,) let req: DataRequest = unimplemented!();Áü¿<9 DataErrorKind::IdentifierNotFound.with_req(marker, req);Á£žúüˆ  Create a named custom error:Á©ú£žüµ#†·üÙ2/ DataError::custom("This is an example error");Á£ž9ŒÁð]Ç$EsÇ£Úòóôõ¼“üî  Broad category of the error.Á$—ññ†\üç ü±1. The data marker of the request, if available.Á4ëññû…ü¸%üŽ%" Additional context, if available.Á\¼ññÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙöŠ„¦üä=: Whether this error was created in silent mode to not log.Á4ªññ(3
Rð]/3Rð]øÙøMOú úð]ð]÷3÷
ø˜ 4¤Sð]Tð]ûû!'<û ûð]úú
û…H6®Uð]Uð]þ·ßþ57üý üð] ýð]ýý
þ¹
(7¹Vð]€Àc!#þÿ þð] ÿ c cˆ¢cµ
 `£c `àB¤GS
ë…ÿÿ
ñÉÔÊü”C@ The request type passed into all data provider implementations.ÁÁó_W•¦6šƒáü©"üë/, The data identifier for which to load data.ÁŸúü§XU If locale fallback is enabled, the resulting data may be from a different identifierÁü„  than the one requested here.Á­bü• !üÑ?< Metadata that may affect the behavior of the data provider.ÁD™ ÿ`8@á[Áó_‡´46ó_
Á(Aê\Áó_ŠÀcŠïò46ƒ ó_  c cˆ¢cµ
 `£c `àB¤GS
ƒë…ˆˆ
ŠÁݱã(Bñ
]ÁŒŒó_âåBF]ÁŽŽó_Ùsu ó_ó_
ÁÅ Cø^Áó_HDþ_Áó_¹¼)-_Áó_–·ßëî[] ó_ ó_
Á½¹
ÃE‰`Á˜˜ó_™Œ4:O ó_E‰
ÁŸô® ü» \Y Metadata for data requests. This is currently empty, but it may be extended with optionsÁü˜
<9 for tuning locale fallback, buffer layout, and so forth.Á9Œœ œ¹ ÿ`˜Ñ´Öñó{œ„¼ üÓ da Silent requests do not log errors. This can be used for exploratory querying, such as fallbacks.Á4À ššüš
!üÒ C@ Whether to allow prefix matches for the data marker attributes.Á¼ž
šš8FÞ
aÿ`ž´ž!#ÿ`
ž(Gç
bÿ` Àc !#ˆŠ ˆÿ`  c cˆ¢cµ
 `£c `àB¤GS
Šë…Ÿ
Ÿ
 Ã±É(Hî

cÿ`/3cÿ`£Ù£MO ÿ`ÿ`¢
¢
£˜
dÿ`HJû
eÿ`eÿ`§·ß§57Œ Œÿ` ÿ`¦