platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e4ebeea1aa4679ca00b951fdc58d376419ce821
boc/aamos-ledger-rust/target/debug/deps/libtinyvec-bb3fd78d7c4e5a88.rmeta
T

543 lines
261 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
rust
ù#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁtinyvec_macrosÁö½‡˜$cþó£OOú¼öI-094edce1c837194aÁ‰)generic_array_implÁ”¹ »
generic-arrayÁÌ™ > PhantomDataÁ\b»serdeÁŒ<> DeserializeÁ\¡»µŒu> DeserializerÁd®»µ!#>DeserializeErrorÁ„Å»µEG> SeqAccessÁL×»µbd>VisitorÁ<⻵}> SerializeÁLž»µŒô> SerializeSeqÁd©»µ"$>
SerializerÁT·»µ@B>TryReserveErrorÁ|��»
rustc_1_57Á´Ï�>ArrayVecVisitorÁ|§£»µŒŒ£>‚$Ë©‚$À©ñ‚$ñÑ‚$æѺ¼|£»Ø´rºŸ\ỵŒ»ºÃ\�»µŒôºãdª»µº§L¸»µ,.ºÄ<ûµACºßLý»µŒÓºþdˆ»µºžT–»µ,.ºTinyVecVisitorÁt¼ú»µŒïùí 
  
 !"#$%¤Ç)M*›*CAPACITYÁ*as_sliceÁ* as_slice_mutÁ*>)const_generic_implÁ002¥2Ÿ2 2›2é2ø2‡ 2>: : &arrayvecÁ>>>>> array_vecÁ>ArrayVecÁD’D‘DdataÁ>H’HƒH†K >M’>O’O>>R’RåR´>V’V>Y’YšY°YÖ>^’^š^×>b’bappendÁb
try_appendÁe'otherÁb
as_mut_ptrÁb as_mut_sliceÁbas_ptrÁbøbcapacityÁbclearÁbdrainÁm£b
into_innerÁbextend_from_sliceÁbfillÁqšbfrom_array_lenÁbinsertÁb
try_insertÁbis_emptyÁbis_fullÁb‘bæ bpopÁbpushÁbtry_pushÁbremoveÁbresizeÁ~ b resize_withÁ€—bretainÁ‚—‚
JoinOnDropÁ„'vecÁ„›„itemsÁ„done_endÁ„
tail_startÁ‚Š›Šãb
retain_mutÁ�—�œ�®�›�Â�Ï�ß�•›•ãbset_lenÁb split_offÁbspliceÁš£šššb swap_removeÁbtruncateÁbtry_from_array_lenÁ>¡’¡from_array_emptyÁ> ¤’¤as_innerÁ>ArrayVecSpliceÁ§'pÁ§’§š§parentÁ§
removal_startÁ§ removal_endÁ§ replacementÁ>
¯³¯’¯š¯›¯ó ¯ size_hintÁ> ³’š‘> »³»’»š>
¿³¿’¿š¿ next_backÁ>ijĒĚÄã>É’Éas_mutÁ>Ì’ÌÉ>Ï’ÏborrowÁ>Ò’Ò
borrow_mutÁ>Õ’ÕextendÁ×¥>Ù’Ù÷>Ü×>Þ¥Þ’ÞErrorÁÞª>ã’ãùå¥>ArrayVecIteratorÁç’çbaseÁçtailÁçÍ
>ì’ìø>ï’>ñ’ñ›ñó ñÂñüñ‹ñnthÁ>ù’ù¯ùnth_backÁ>ý’ý‘>€’€×>ƒ’ƒ›ƒIntoIterÁƒê>ˆ'aÁˆ’ˆ›ˆÏˆê> ŽëŽ’Ž›ŽÏŽê>!”’”�>"—’>#™’™ï
>$œ’œ‹>%Ÿ’Ÿ�>&¢’¢�>'¥’¥§§™>(©’©×>)¬’¬×>*¯’¯×>+²’²×>,µ’µ×>-¸’¸×>.»’»×>/¾’¾×>0Á’Á×>>1Å’Ådrain_to_vec_and_reserveÁÅ drain_to_vecÁ'arrayvec_drainÁÊÊÊÊÊÊÊ
ArrayVecDrainÁÑëÑ¥ÑùÊÕëÕ¥Õæ ؒأÊÛëÛ¥Û¯ÛƒÊàëà¥à›àó àÂàäà‹àfor_eachÁè—Êêëê¥Êíëí¥(slicevecÁññSliceVecÁó'sÁó¥óÍ
ó‘ñø¢ø¥ø>ñü¢ü¥üåü´ñ�¢�¥�ñ…¢…¥…š…°…Öñ‹¢‹¥‹š‹×ñ�¢�¥�€ �« �¼ �Ï �ø�ã �ò �þ š³š£š�¢
�º
Ÿš�from_slice_lenÁ�á
�ÿ
�Ž�‘�ª�´�Î�Û© �ì«—�†­—­œ¯®¯›¯Â¯Ï¯ß­µ›µã�ã�ñ¹ë�£�µ�try_from_slice_lenÁñ¾¢¾¥¾Žñ¢¥Â÷ñƢƥƒÆ÷ñ
SliceVecDrainÁ˳ˢ˥ËÍË target_startÁË target_indexÁË
target_endÁñ Ó³Ó¢Ó¥Ó›Óó ñ
ٳ٢٥ñ ݳݢݥÝãñ â¢â¥âðñ
æ¢æ¥æÉñê¢ê¥êžñî¢î¥î¸ñò¢ò¥òÖõšñ÷¢÷¥÷›÷Ï÷êñý¢ý¥ý�ñ�¢�¥ñ„¢„¥„ï
ñˆ¢ˆ¥ˆ‹ñŒ¢Œ¥Œ�ñ�¢�¥�§“™ñ•¢•¥•×ñ™¢™¥™×ñ�¢�¥�×ñ¡¢¡¥¡×ñ¥¢¥¥¥×ñ©¢©¥©×ñ­¢­¥­×ñ±¢±¥±×ñ µ¢µ¥µ×)tinyvecÁºººººººtiny_vecÁºTinyVecConstructorÁÂ’ÂInlineÁÄ
ĈÂHeapÁÇ
LjºTinyVecÁÊ’Ê�,Ì
̈ʫ,Ï
ψºÒ’ÒƒÒ†ºÖ’Ö>ºÙ’ÙåºÜ’ºÞ’ÞšÞ°ÞÖºã’ãšã׺ç’çis_heapÁç is_inlineÁç
shrink_to_fitÁçmove_to_the_heapÁçmove_to_the_heap_and_reserveÁçreserveÁç
reserve_exactÁç
with_capacityÁçinto_boxed_sliceÁçinto_vecÁºó’ó€ ó†ö—ó¼ óøóò óþ û£ó¢
óÌ
óconstructor_for_capacityÁóá
óÿ
óæ ó´ƒdrain_to_heap_and_pushÁ„’óÛ† ó숗óñó�‹£‹š‹óĺ TinyVecDrainÁ�³�’��,“
“ˆ�«,–
–ˆº™³™’™›™¸�—º Ÿ³Ÿ’º
TinyVecSpliceÁ¢³¢’¢š¢Í¢Û¢ð¢ƒº
ª³ª’ªšª›ªó ªÂº ±³±’±š±‘º ³’šº
º³º’ºšº¯º¿³¿’¿š¿ãºÄ’ÄðºÇ’ÇɺʒʞºÍ’͸ºÐ’ÐÖÒ¥ºÔ’Ô÷º×’×÷ºÚ¥Ú’Ú÷ºÞ¥Þ’Þ÷ºâ’âù䥺æ’æintoÁºTinyVecIteratorÁé’é�,ë
ëˆé«,î
ñ’ºó’ºõ’õ›ºø’ºú’ºü’ü׺ ÿ’ÿ›ÿÏÿêº!„ë„’„›„Ï„êº"ŠëŠ’Š›ŠÏŠêº#�’��º$“’º%•’•ï
º&˜’˜‹º'›’›�º(ž’ž�º)¡’¡§£™º*¥’¥×º+¨’¨×º,«’«×º-®’®×º.±’±×º/´’´×º0·’·×º1º’º×º2½’½×*>TryFromSliceErrorÁÁ
Áˆ>2Ä×>3>4>5ȃٴÜó£óªóÎó‘óã óµó« óÏ ™ó ™ä™Â™‹™üŸ¯Ÿƒñøõó õÂõüõ‹õäø¯øƒú‘-
.
8
9
J
K
K
U
X
]
a
d
d
e
g
h
i
j
k
l
m
p
p
q
t
u
v
w
x
z
{
|
}
~
€
‚
‚
Š
Œ
�
�
•
—
˜
™
š
ž
Ÿ
¦
´
µ
º
Ã
È
Ë
Î
Ñ
Ô
×
Ý
Ý
Ý
Þ
â
î
ô
õ
ø
û
ü
ÿ
‚
‚
‚
–
–
›
›
ž
ž
Ÿ
¡
¡
¡
¢
¤
¤
¤
§
§
«
«
«
®
®
®
±
±
±
´
´
´
·
·
·
º
º
º
½
½
½
À
À
À
Ã
Ã
Ã
Ç
È
Þ
ß
ä
å
æ
€
„
Š
�
“
“
”
•
–
—
˜
™
ž
ž
Ÿ
¢
£
¤
¥
¦
§
¨
©
«
­
­
µ
·
¸
»
¼
Á
Ø
á
å
é
í
ñ
õ
€
€
‡
‡
‹
‹
Œ
�
�
�
“
“
˜
˜
˜
œ
œ
œ
 
 
 
¤
¤
¤
¨
¨
¨
¬
¬
¬
°
°
°
´
´
´
¸
¸
¸
Ô
Õ
Õ
â
æ
é
ê
ë
ì
í
î
ï
õ
õ
ö
ö
ø
ù
ú
û
ý
ý
€
�
ƒ
„
†
ˆ
Š
‹
¯
°
µ
¾
Ã
Æ
É
Ì
Ï
Ò
Ú
Ý
Þ
á
þ
þ
þ
’
’
—
—
š
š
›
�
�
�
ž
 
 
 
£
£
§
§
§
ª
ª
ª
­
­
­
°
°
°
³
³
³



¹
¹
¹
¼
¼
¼
¿
¿
¿
Å
Å
Å
É
Ê
Ë
Ì
Í
Î
Ï
Ð
Ñ
Ò
Ó
Ô
Õ
Ö
Ù
Ú
Û
Ü
Ý
à
á
â
ã
**¥ŸØDD°
F‘>GÍ
úÊþ ÙÕ´’Š åK³åKé!åKö!åKÙ¢åKš³"åKÒLŒ"„„œ‡Â>ˆÏ>‰ß>¯ ÐZ{èS8›Œ"��œ’Â>“Ï>”ß>9Æ•¬ð$ð8´MùM§§�«Í>¬Û>­ð>®ƒ>ˆ*.½œ¡B³’šÃM“NòP“NŒM“NŒ"“NãåK
™L+àåK¥O åK¥O£åK¥OÐLåK¦OéåK™L¿cÁÁ¨<È> ü ÓˆŽ�Š ÷OÛ÷OØ÷OÄc÷OðDD°
F‘>GÍ
úÊþ ÙÕ´’ 8
¥ÃLåK¦OòPççÐéð>êü>ëÍ
>Ó8D±¾™LùM²QŒM²QÃM²Q¿c²QÇLåKÇL ëDD°
F‘>GÍ
úÊþ ÙÕ´çNÇL ë·RµßåKåK™åKíßåKåKºåKµß·R 8çNµß·R 8
çN+šeåKÈcåK¿cåKÄcåKÐcåKÊcåKÆcåKÎcåKÒcåKÌcåKŒMÑÑüÔùÊëÈ aÔ}�Të—QùMÊTòPÊTÃMÊT³óó’öÍ
ñ÷‘ñ¶hŽ®¬©*¢—Qé!¦Uö!¦UÙ¢¦UíN³"¦UíNŒ"¯¯œ²Âñ³Ïñ´ßñô+…òäi=8´Mé¦U ¢–Qé¦U ¢‹QùMËË×$ÏÍñÐŒ%ñÑ %ñÒ´%ñe¬*GUÚÞH³¢¥òPœWŒ"œWã¦U–Qà¦U–Q ¦U–Q£¦U–QÐL¦U—QÇL¦Uµß¦U¦U™¦UíߦU¦Uº¦Uµßóó’öÍ
ñ÷‘ñ¶hŽ®¬©*¢úW 8
úWše¦UÈc¦U¿c¦UÄc¦UÐc¦UÊc¦UÆc¦UÎc¦UÒc¦UÌc¦UØÊÌÍ�,ΈÏЫ,шÞP7nÎ…_™L³ÏZé!ÏZö!ÏZÙ¢ÏZÒL³"ÏZÒLùM�“”�,•ˆ–—«,˜ˆ�‘†ÇøŒÇ³çNŒMÚ[ùM¢¢–3¦Íº§Ûº¨ðº©ƒºØPOŸ¤CÁ³çNíNÃM¼\òP¼\ŒM¼\Œ"¼\ãÏZ¥OàÏZ¥O ÏZ¥O£ÏZ¥OÐLÏZ¦OéÏZåKéÏZ™LéÊÌÍ�,ΈÏЫ,шÞP7nÎ…_‹Q‘Qé¤^ 8–QÃLÏZ¦OæÏZªBªBö­BbufÁ÷<®B‘÷<9)
-ÜnL¦OçEçEèEGlobalÁ ¿±‡§í#òPéëì�,íˆîï«,ðˆœ5ÝuOý²™LùM�`ŒM�`ÃM�`¿c�`ÇLÏZÇL ëÊÌÍ�,ΈÏЫ,шÞP7nÎ…_çNÇL ë™aµßÏZÏZ™ÏZíßÏZÏZºÏZµß™a»Sµß™aÏSšeÏZÈcÏZ¿cÏZÄcÏZÐcÏZÊcÏZÆcÏZÎcÏZÒcÏZÌcÏZ2HDÈÁÒÊMDÆÁODøóÖÊRDüóÙÊVD�óÜÊYD…óÞÊ^D‹óãÊŠ„•�ħµ¯ÝË¿¢¯§ñçàÑÓË™�ª¢õé§ýçíѱ¢ú黧ïçêÑÙË¢ó鿧ùçÛÑŸ�º¢øéÉDâóÄÊÌDæóÇÊÏDêóÊÊÒDîóÍÊÕDòóÐÊÙDÂóÆóÔÊ×ÊÚÊÞÊÄÁ€ç¬D™óüé¨ÊÇÁÜÁ¯D�ó«ÊÞDãDâʃDˆ
Ž
÷óÿÊ„
Š
”DŸD¢DýóŒó�ʛʞʗD�ó“Ê™D„ó•ÊœDˆó˜Ê¥D�ó¡Ê©D•ó¥Ê²D¡ó®ÊµD¥ó±Ê¸D©ó´Ê»D­ó·Ê¾D±óºÊÁDµó½ÊæÊ*…ØŠ ³ é!ö!Ù¢³"Œ"ùM*ÃM1òP#ŒM*ã*à £ÐLé¿c0Û)ÄcðÃLÇL
µß(™5íߺšeÈcÐcÊcÆcÎcÒcÌcæ r ŸÔZ7ýk,j!<ýkŸNÁ$è„ ¬á„ D™L ó„ õ„ú„£ü¬„NåK$Ö„™L$Ê„™L|Í
7T¾• ™L Ë•Ì•¦ü••7 ™Lµ• åK,«•³nl<\¦‚  –Q) ´‚µ‚Áüû�: –Q$›‚ óó’öÍ
ñ÷‘ñ¶hŽ®¬©*—Q,‘‚Îo·†o䤵 ÁÂ&÷O18?4í ™LÅ(ÂÄÅ�,ƈÇÈ«,Ɉ±™*–lof™L{åKÏZŠ‘$– ™LÈ(Ëq3œ_ÏZBI4’ Ê™LÍ(ÏZ3åK:A$ ʙLÐ(ÏZ3œ_:A4éÿ �çN”+�“”�,•ˆ–—«,˜ˆ�‘†ÇøŒÇçN€ÑÑüÔùÊëÈ aÔ}�TÕS·¾$¨€ �çN—+ât6ˆ>ˆ>DrainÁŒ>ß÷<�>tail_lenÁ÷<Ž>ù÷<�>Á÷<…üò)«§ÕSÜ_¡¨4—¸ é™Lì)�`4²Q;B$ϸ é™Lï)�`4ˆ?ˆ?Ï‹?¯^÷<Œ?phantomÁ÷<�?capÁ÷<Ž?¤÷<�?µ ÷<�?þ÷<µqS·l·¦OÜ_²¹)>ÊñºíY4Ý ZL売Løµß²˜N,Žãq< ³ qµ BinaryÁ4¶Èc p,¾¿c pÂc t<ÅÄc
ˆLΠcLowerExpÁDÙÐcLowerHexÁDãÊcOctalÁ,íÆc<ôÎcUpperExpÁD�ÒcUpperHexÁD‹ÌcŽ$£šeŽ e‘4©¢eExtendÁ4»ÐL‹dÃÃL
FusedIteratorÁlÑòP˜dàÇL�DîùMÚ T� ÐreplaceÁ<� Û r,Ÿé!"DerefMutÁD¦ö!#IndexÁ,°Ù¢$IndexMutÁD·³"% RangeBoundsÁ\Á¤#&ÚTØ“k'¤,º( 
LéCÞ+D‰ ÁM,ž*=°
D‘DÉ�tü˜§ÉЄÝÁçÉül¨Ñð’Dûó¹×$l�”˹î+”ÌÂÀÄ,<ãÊÀ†2d±ÿ�À–3lóˆ¢À¯7|à·éÀ¨<Œ¯µÁÉü³üî:7 `tinyvec` provides 100% safe vec-like data structures.Á©ú¬­ ## Provided TypesÁüÃNK With no features enabled, this crate provides the [`ArrayVec`] type, whichÁü’OL is an array-backed storage. You can push values into the array and pop themÁüâOL out of the array and so on. If the array is made to overflow it will panic.Á²úü¶OL Similarly, there is also a [`SliceVec`] type available, which is a vec-likeÁü†NK that's backed by a slice you provide. You can add and remove elements, butÁüÕ,) if you overflow the slice it will panic.Á‚ úü† LI With the `alloc` feature enabled, the crate also has a [`TinyVec`] type.ÁüÓ PM This is an enum type which is either an `Inline(ArrayVec)` or a `Heap(Vec)`.Áü¤
NK If a `TinyVec` is `Inline` and would overflow it automatically transitionsÁüó
52 itself into being `Heap` mode instead of a panic.Á© úü­ OL All of this is done with no `unsafe` code within the crate. Technically theÁüý LI `Vec` type from the standard library uses `unsafe` internally, but *thisÁüÊ =: crate* introduces no new `unsafe` code into your project.Áˆ
úüŒ
IF The limitation is that the element type of a vec from this crate mustÁüÖ
PM support the [`Default`] trait. This means that this crate isn't suitable forÁü§OL all situations, but a very surprising number of types do support `Default`.Á÷ú¬û ## Other FeaturesÁü‘MJ * `grab_spare_slice` lets you get access to the "inactive" portions of anÁ|ß ArrayVec.ÁüïIF * `serde` provides a `Serialize` and `Deserialize` implementation forÁü¹MJ [`TinyVec`] and [`ArrayVec`] types, provided the inner item also has anÁ¬‡ implementation.Áü�OL * `borsh` provides a `BorshSerialize` and `BorshDeserialize` implementationÁüíNK for [`TinyVec`] and [`ArrayVec`] types, provided the inner item also hasÁļ an implementation.ÁüÕLI * `defmt` provides a `Format` implementation for all types, provided theÁü¢,) inner item also has an implementation.ÁÏúTÓ ## APIÁüÞMJ The general goal of the crate is that, as much as possible, the vecs hereÁü¬MJ should be a "drop in" replacement for the standard library `Vec` type. WeÁüúFC strive to provide all of the `Vec` methods with the same names andÁüÁPM signatures. The exception is that the element type of some methods will haveÁü’?< a `Default` bound that's not part of the normal `Vec` type.ÁÒúüÖMJ The vecs here also have a few additional methods that aren't on the `Vec`Áü¤IF type. In this case, the names tend to be fairly long so that they areÁüî=: unlikely to clash with any future methods added to `Vec`.Á)>ÊñºílYm Zl£²kµß²~˜Nkãqj³ q{µ ÞydÈc pc¿c ptÂc tcÄc
ˆb c¿zYÐcÚzPÊcõzJÆcIÎc {@Òc»{7ÌcŽ6šeŽH e‘6¢eŽ|/ÐL‹.ÃLº| òP˜ÇL�ùMÚ  Г} Û ré!"¿} ö!#Ú}Ù¢$ó}ü³"%Ž~ð¤#&Úï“k'¤î( 
íCÞ+ìÁMë*=°
êDÉ�é§ÉÐççÉüåÑð’äó¹×$ã˹î+áÂÀÄ,àÊÀ†2ß�À–3Ý¢À¯7ÛéÀ¨<ÙÁÉàãæ$Ê„ÊâåÖÙtóÍt…¯„—¤üÊd‚…vyY\LO7:"%îñÙÜüÊÖÒÕ³üÊ™œ‚ruehüÊ´^aJMüÊÒDG/2 
ïòŒÑæ´©ÚLÂ,Æ*0|”ü(% A trait for types that are an array.Á)úü-?< An "array", for our purposes, has the following properties:Áüm# * Owns some number of elements.Áü‘FC * The element type can be generic, but must implement [`Default`].ÁüØLI * The capacity is fixed at compile time, based on the implementing type.Áü¥<9 * You can get a shared or mutable slice to the elements.ÁâúüæPM You are generally **not** expected to need to implement this yourself. It isÁü·.+ already implemented for all array lengths.Áæú´ê ## Safety ReminderÁ�úü…LI Just a reminder: this trait is 100% safe, which means that `unsafe` codeÁüÒA> **must not** rely on an instance of this trait being correct.ÁÕ**Îìü”ä*ݧݧ+,-./+,-./Íìå§+œÒ³Ÿ¨<Ý—¨®¨-./”Òü¨'$ The type of the items in the thing.Á$×**¬‘üé%" The number of slots in the thing.ÁD—**ýküÈ$ü«.+ Gives a shared slice over the whole thing.ÁÜúüâKH A correct implementation will return a slice with a length equal to theÁ¬° `CAPACITY` value.ÁDËä äå§ ä
Ÿ¨* Ô*
-å§$Õü� 0üð.+ Gives a unique slice over the whole thing.Á¡úü§K·©¬õ‹ªd� å åå§ åÕ«* � *
.å§$¢ ¬á
üÁ DA Create a default-initialized instance of ourself, similar to theÁüˆ
EB [`Default`] trait, but implemented for the same range of sizes asÁtÐ
[`Array`].Á<ä
å§**
/姴ú
”þ
)M, *01dü1¥3Ÿ434ÍìÓK Ÿýkt$³ÓK<ÒK6789:+,-./89:CEC *ýkLI$N22ÓK¬ZD`22ýkÔŒD�æ æÒK æ
ÓK2 ˜2
8ÓKŸ$™üÏ&dÒç çÒK 縱2 ß2
9ÓKŸ$䤢<¥ÒK22
:ÓKŸÉ:<closure_kind>Á<<closure_signature>Á<<upvars>Á<<:<ÓKŸƒqÓKƒq,ÕdàDäD§çÁÂí<"ð>Aî<+ì>Bö¬�ªB>ÄYˆ >?ZŠ£>?²Œµß>?²¢˜>?N’ã>?q”³>? q¨µ>? Þy”Èc>? p–¿c>? pªÂc>? tœÄc>?
ˆž c>?¿z˜Ðc>?Úz’Êc>?õz�Æc>?‘Îc>? {‹Òc>?»{…Ìc>?Ž‡še>?Žœ e>?‘�¢e>?Ž|‰ÐL>?‹‹ÃL>?º|€òP>?˜‚ÇL>?�„ùM>?Ú † Ð>?“}� Û>? rƒé!>?"¿}}ö!>?#Ú}zÙ¢>?$ó}t³">?%Ž~k¤#>?&Úm“k>?'¤o>?(Ç  )>?�
7>>? 
•C>?ÈtˆÊ>?ýD¸ñ>?±+<öº>?Þ+ÒÁ>?MÖ*>?=ü£Ñ>?ð’§ó>?¹×$«Ë>?¹î+®Â>?ÀÄ,²Ê>?À†2�>?À–3¹¢>?À¯7¼é>?À,l\_PS´ÜüÅ! Helper to make an `ArrayVec`.ÁçúüëPM You specify the backing array type, and optionally give all the elements youÁü¼+( want to initially place into the array.Áèú\ì ```rustÁœø use tinyvec::*;ÁŒúü�@= // The backing array type can be specified in the macro callÁüÑ(% let empty_av = array_vec!([u8; 16]);Áüú41 let some_ints = array_vec!([i32; 4] => 1, 2, 3);Á¯úܳ // Or left to inferenceÁüÏ41 let empty_av: ArrayVec<[u8; 10]> = array_vec!();Áü„?< let some_ints: ArrayVec<[u8; 10]> = array_vec!(5, 6, 7, 8);Á<Ä ```Á(|Ìa! ó §
 ÷ Ÿ , ø8
array_typeÁTù& ƒ8´„*‡, Š ‹ –, Œ8elemÁ$�& ‘8›$’$ —
˜, š › �$ œ- ž*¡ ¤ Ÿ ª ›8²88avÁº& ¼, ¾8,¿'Ä8°
DÆ Î, Ï8×ÁTÐ Ú Ü8q<Þ'å8><ç î ï% ð, ø ù ‹8¦Ãû ý8´$þ ‚ ˆ, ƒ8 Â$„% ‰
Œ8¦Ã”%   ¤ ³, ¥8×ÁT¦& °8´±*µ ¸ ë , ¾8,¿'Ä8°
DÆ'Î Ð, Ñ8×ÁTÒ Ü'Ý8><ß æ ç% ì ð € , ñ ò ý, ó8 Â$ô& ø8›$ù$ þ
ÿ*‚  …  ± , ‹ 8,Œ '‘ 8 
L“  œ  �  ­ 8 ž *  , £  ¤  ª , ¥ 8 Â$¦ $ « 
¬ % ²   Ê  , · 8 Â$¸ & ¼ 8›$½ % Á , Ã 8¹ Ä & Å 8›$Æ *Ì  Ï  û , Õ 8,Ö 'Û 8°
DÝ 'å 8÷$ç  ë  ÷  ì  ö , í 8 Â$î % ò , ô 8¹ õ % ü  €
 �
*ƒ
 †
 ¤
, Œ
8,�
'’
8 
L”
 �
 ž
  
8 Ÿ
% ¥
´†üª
0- An array-backed, vector-like data structure.ÁÛ
úüß
MJ * `ArrayVec` has a fixed capacity, equal to the minimum of the array sizeÁü­ OL and `u16::MAX`. Note that not all capacities are necessarily supported byÁüý )& default. See comments in [`Array`].Áü§ PM * `ArrayVec` has a variable length, as you add and remove elements. AttemptsÁüø =: to fill the vec beyond its capacity will cause a panic.Áü¶
LI * All of the vec's array slots are always initialized in terms of Rust'sÁüƒPM memory model. When you remove an element from a location, the old value atÁüÔ>; that location is replaced with the type's default value.Á“úü—MJ The overall API of this type is intended to, as much as possible, emulateÁüåOL the API of the [`Vec`](https://doc.rust-lang.org/alloc/vec/struct.Vec.html)ÁLµ type.Á¿úœÃ ## ConstructionÁ×úüÛPM You can use the `array_vec!` macro similarly to how you might use the `vec!`Áü¬NK macro. Specify the array type, then optionally give all the initial valuesÁ¬û you want to have.Á\‘ø½¬� # use tinyvec::*;Áü³4±¿üè# assert_eq!(some_ints.len(), 3);Á<Œ¥Á”úü˜IF The [`default`](ArrayVec::new) for an `ArrayVec` is to have a defaultÁüâIF array with length 0. The [`new`](ArrayVec::new) method is the same asÁ¬¬ calling `default`Á\Âø½¬ÎÑÔüä41 let some_ints = ArrayVec::<[i32; 7]>::default();Áü™# assert_eq!(some_ints.len(), 0);Á½úüÁ0- let more_ints = ArrayVec::<[i32; 7]>::new();Áüò%" assert_eq!(some_ints, more_ints);Á<˜¥Á úü¤NK If you have an array and want the _whole thing_ to count as being "in" theÁüóMJ new `ArrayVec` you can use one of the `from` implementations. If you wantÁüÁ(% _part of_ the array then you can useÁüê1. [`from_array_len`](ArrayVec::from_array_len):Á\œø½¬¨ÑÔü¾1. let some_ints = ArrayVec::from([5, 6, 7, 8]);Áüð# assert_eq!(some_ints.len(), 4);Á”úü˜>; let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);Áü×# assert_eq!(more_ints.len(), 2);ÁûúüÿQN let no_ints: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([1, 2, 3, 4, 5]);ÁüÑ! assert_eq!(no_ints.len(), 0);Á<ó¥ÁÑ/’EEÍì™L šåKúÊþ ÙÕ´FGD¡¡>DDþl”­$¸DD™LüÄI’IIëß É*™L,íØ™L,õئO,‡åKJKÙÚJKEG¼ž,¡è èåKåKH §H
J™L$¨üÿ"T‚éê éåK êåKƒqH �H
K™L$’º ˜ƒ K¤²L¼²LÙ²LLKL™L ¦OƒqƒqüÅ F’NNëß Ê õà,í Š ™L$õ Š ¦O$†!åK-/ü‘!&’PPëß –!õà,™!åKQ´Q¤È!<Ë!åKOO
Q™LüŽ"$’SSëß “"õà,–"åKTUê!ë!U \·"4¼"RR¥Oüæ" ,é"ë ëåK ëåKê!R ï"R
U™L$ð"ü¿#'’WWëß Ä#õà,Ç#åKX÷!Xüÿ#,L‚$ì ìåK ìØæV Œ$V
X™L$‘$üì$A’Zš[[Zëß ñ$ÍìÒL û$õà,ô$“kÒL¥O¬þ$åK\]ۢܢ]BD?A\²%4·%YYÒL¥O•küü%*,ÿ%€í íåKÒL íåKÒLÛ¢Y …&Y
]™LÒL$†&Ö,Œ&üÉ&D’_š``_ëß Î&Ùè Ø&õà,Ñ&ñè¬Û&åKaµ"a(*-/ü¦'6L©'€î îåKÒL î�ê^ ³'^
a™LÒL$¸'Ö,¾'Ô–>’ccëß ›>õà,ž>åKdeghijklmopqstuvwxyz{|}~€‚�˜
## PanicsÁüý>'$ * If the vec overflows its capacityÁ§?út­? ## ExampleÁ\¾?ø½¬Ì?ÑÔüä?2/ let mut av = array_vec!([i32; 10] => 1, 2, 3);Áü™@30 let mut av2 = array_vec!([i32; 10] => 4, 5, 6);ÁÄÏ@ av.append(&mut av2);Áüê@,) assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);Áì™A assert_eq!(av2, &[][..]);Á<¹A¥Á4ÖAïð ïåK ðåKƒqb ÝAb
d™L$âA¹
,èAü�Hbü±C/¼ìüãCFC If appending would overflow the capacity, Some(other) is returned.Át¬DÓí\½Dø½¬ËDÑÔüãD1. let mut av = array_vec!([i32; 7] => 1, 2, 3);Áü—E2/ let mut av2 = array_vec!([i32; 7] => 4, 5, 6);ÁÄÌEýîüçE,Ÿïì–FÔï¶Fúü¼F2/ let mut av3 = array_vec!([i32; 7] => 7, 8, 9);ÁüñF/, assert!(av.try_append(&mut av3).is_some());Áü£G,ŸïüÒG$! assert_eq!(av3, &[7, 8, 9][..]);Á<ùG¥ÁT–Hfñ ñåK fåKÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙˆöb4¡Hb
e™L$³H¹
,¹H ü¨L,üúJ*' A `*mut` pointer to the backing array.Á§Kúl­K
## SafetyÁ½KúüÃK@= This pointer has provenance over the _entire_ backing array.Á.\šLT¯Lò òåK ¦Ob ºLb
g™L$¿LüàM0üˆM30 Performs a `deref_mut`, into unique slice form.Á.\ÒMdçMó óåK ó¥Ob ôMb
h™L$ùMüßO&ü¯N,) A `*const` pointer to the backing array.ÁÞNúläN×öôNúüúN@úö.\ÑO4æOô ôåK ¦Ob íOb
i™L$îOü…Q$ü±P/, Performs a `deref`, into shared slice form.Á.\÷PDŒQõ õåK õ¥Ob •Qb
j™L$–QüøRüÄQ# The capacity of the `ArrayVec`.ÁêQúüðQMJ This is fixed based on the array type, but can't yet be made a `const fn`ÁœÀR on Stable Rust.Á.\êRDÿRö öåKýkb ˆSb
k™L$‰S¼þUü¹U.+ Truncates the `ArrayVec` down to length 0.Á,…V÷ ÷åKƒqb ‹Vb
l™L$�VüúZeü´VNK Creates a draining iterator that removes the specified range in the vectorÁü…W! and yields the removed items.Á©Wúl¯W€íü¿W*' * If the start is greater than the endÁüìW-* * If the end is past the edge of the vec.ÁœXút¢XÓí\³Xø½¬ÁXÑÔüÙX1. let mut av = array_vec!([i32; 4] => 1, 2, 3);Áü�Y:7 let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();ÁüÊY(% assert_eq!(av.as_slice(), &[1][..]);ÁüõY,) assert_eq!(av2.as_slice(), &[2, 3][..]);Á¤ZúŒªZ av.drain(..);Áü¾Z# assert_eq!(av.as_slice(), &[]);Á<äZ¥Á,�[ø øåK£ÑÑüÔùÊëÈ aÔ}�Tø¦Ob£nn Š[bÍìÜ… ‡[¤#Ü…ýk”Ì[
m™LÜ…$�[rangeÁ,•[68ä€cü�\.+ Returns the inner array of the `ArrayVec`.ÁÀ\úüÆ\KH This returns the full array, even if the `ArrayVec` length is currentlyÁœ”] less than that.Áª]út°]ÓíÁ]ú\Ç]ø½üÕ])& # use tinyvec::{array_vec, ArrayVec};Áü�^IF let mut favorite_numbers = array_vec!([i32; 5] => 87, 48, 33, 9, 26);ÁüÍ^KH assert_eq!(favorite_numbers.clone().into_inner(), [87, 48, 33, 9, 26]);Á›_úÜ¡_ favorite_numbers.pop();Áü¿_B? assert_eq!(favorite_numbers.into_inner(), [87, 48, 33, 9, 0]);Á<„`¥ÁŽ`úü”`JG A use for this function is to build an array from an iterator by firstÁüá`%" collecting it into an `ArrayVec`.Á‰aú\�aø½ä�a # use tinyvec::ArrayVec;Áü¼aJG let arr_vec: ArrayVec<[i32; 10]> = (1..=3).cycle().take(10).collect();Áü‰b%" let inner = arr_vec.into_inner();Áü±b63 assert_eq!(inner, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]);Á<êb¥ÁT‡cåK™Lbb
o™L$’cüÍdPü´c96 Clone each element of the slice into this `ArrayVec`.Áðcúlöc€íü†d85 * If the `ArrayVec` would overflow, this will panic.ÁŒÔdùú ùåK ú¥Oƒqb ædb’á,—e
p™L$ëdsliÁñdü§pXü¯h85 Fill the vector until its capacity has been reached.ÁêhúüðhIF Successively fills unused space in the spare slice of the vector withÁü¼iFC elements from the iterator. It then returns the remaining iteratorÁü…jDA without exhausting it. This also allows appending the head of anÁ´Ìj infinite iterator.ÁåjúüëjIF This is an alternative to `Extend::extend` method for cases where theÁü·kHE length of the iterator can not be checked. Since this vector can notÁü‚lFC reallocate to increase its capacity, it is unclear what to do withÁüËlC@ remaining elements in the iterator and the iterator itself. TheÁü‘mEB interface also provides no way to communicate this to the caller.ÁÙmú
$µx‘¾xüõ}5ü­zKH Inserts an item at the position given, moving all following elements +1ÁTûz index.Áˆ{úlŽ{€íÄž{ * If `index` > `len`Áü¹{" * If the capacity is exhaustedÁÞ{útä{Óí\õ{ø½œƒ|Œ¾ü™|2…î¤Î| av.insert(1, 4);Áüå|-* assert_eq!(av.as_slice(), &[1, 4, 2, 3]);Á¤•} av.insert(4, 5);Áü¬}0- assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);Á<ß}¥Á4ü}ü üåKýk¦Oƒqb ƒ~b
t™L$ˆ~Ö,Ž~÷$œ~üăYü GD Tries to insert an item at the position given, moving all followingÁ´ê elements +1 index.Áüƒ€:7 Returns back the element if the capacity is exhausted,ÁÜÀ€ otherwise returns None.ÁÞ€úl䀀íÄô€ïž��út•�Óí\¦�ø½œ´�Œ¾üÊ�HE let mut av = array_vec!([&'static str; 4] => "one", "two", "three");ÁÌ•‚ av.insert(1, "four");Áü±‚@= assert_eq!(av.as_slice(), &["one", "four", "two", "three"]);Áüô‚74 assert_eq!(av.try_insert(4, "five"), Some("five"));Á<®ƒ¥ÁT˃ý ýåKýk¦OÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¦Ob Ûƒb
u™L$àƒÖ,æƒ÷$øƒôÑ‹ôŽ‹ Checks if the length is 0.Á.\ËDØ‹þ þåKb á‹b
v™L$â‹ìÞŒü‹Œ.+ Checks if the length is equal to capacity.Á.\ÐŒ<åŒÿ ÿåKb íŒb
w™L$îŒÔû�ü§�/, The length of the `ArrayVec` (in elements).Á.\í�‚Ž€ €åKýkb †Žb
x™L$‡Ž¤üŽüµŽ" Makes a new, empty `ArrayVec`.Á.\�åKbb
y™Lü¨’(ü®�C@ Remove and return the last element of the vec, if there is one.Áô�útú� ## FailureÁü‹�)& * If the vec is empty you get `None`.Á·�út½�Óí\Î�ø½¬Ü�ÑÔüô�/, let mut av = array_vec!([i32; 10] => 1, 2);Áü¦‘" assert_eq!(av.pop(), Some(2));ÁüË‘" assert_eq!(av.pop(), Some(1));Áüð‘ assert_eq!(av.pop(), None);Á<’’¥Á¯’� �åK�¨b ³’b
z™L$¸’üÝ—$üŽ”-* Place an element onto the end of the vec.Á¾”úlÄ”€íüÔ”;8 * If the length of the vec would overflow the capacity.Á’•út˜•Óí\©•ø½¬·•ÑÔüÏ•&# let mut av = array_vec!([i32; 2]);Áäø• assert_eq!(&av[..], []);Á|—– av.push(1);Áì©– assert_eq!(&av[..], [1]);Á|É– av.push(2);ÁüÛ–  assert_eq!(&av[..], [1, 2]);Áüþ–>; // av.push(3); this would overflow the ArrayVec and panic!Á<¿—¥Á$ä—‚ ‚åK¦Oƒqb é—b
{™L$î—¹ô—üÐœ;üë˜74 Tries to place an element onto the end of the vec.\Áü¥™:�£Üâ™Ô£\€šø½¬ŽšÑÔü¦š&•²üÏš" assert_eq!(av.as_slice(), []);Áüôš%" assert_eq!(av.try_push(1), None);Á윛„³ü¼›%" assert_eq!(av.try_push(2), None);Áüä› ųü‡œ(% assert_eq!(av.try_push(3), Some(3));Á<²œ¥ÁDלƒ ƒåK¦O�¨b àœb
|™L$圹ëœü–¢1ü�ŸGD Removes the item at `index`, shifting all others down by one index.ÁןúüÝŸ  Returns the removed element.Á€ úl† €í– úüœ $! * If the index is out of bounds.ÁàútÉ ÓíÚ ú\à ø½¬î ÑÔü†¡1ó�üº¡  assert_eq!(av.remove(1), 2);ÁüÝ¡  assert_eq!(&av[..], [1, 3]);Á<€¢¥Á4�¢„ „åKýk¦Ob ¤¢b
}™L$©¢Ö,¯¢üôªVü´§-* As [`resize_with`](ArrayVec::resize_with)Áüä§+( and it clones the value as
p *= 2;Á<ˆ° pÁ<’° });Áüœ°'$ assert_eq!(&av[..], [2, 4, 8, 16]);Á<Æ°¥Á\ã°† †åKýk—ƒqb—�� ‹±bÍìŒÉ ï°“"ŒÉƒq”ò°ŒÉƒq˜"¦O<ý°
€™LŒÉ$�±¼Á<–±± ª±VXü¸µGü‰³JG Walk the vec and keep only the elements that pass the predicate given.ÁÖ³útܳÓíí³ú\ó³ø½¬�´ÑÔ™´úüŸ´;8 let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);ÁüÝ´ av.retain(|&x| x % 2 == 0);Áüÿ´  assert_eq!(&av[..], [2, 4]);Á<¢µ¥Á4¿µˆ ˆåKŒÉƒqb—ƒƒ âµb·É Ƶ‡“"ŒÉ ‡¦O¼Éµ‡ŒÉë͘"$ܵ
‚™LŒÉ$çµ
acceptableÁTñµlnì߶Tæ¶>®…›†…†Íì´M$÷¶´M®¼…·„„œ‡Â>ˆÏ>‰ß>¯ ÐZ{èS®´M¯ ÐZ{èS‡ˆ‰Œ$ñ¶„†‚,…·>„„ ®
´M|¤·D¤·>„„ýkŒê·Tê·>„„ýküˆ¸(8‰›‹‹‰ƒÏ$�¸ìLŒ�"Œ”¹¸$¼¸Š ŠìLƒqŠ Á¸Š
Œ8´M$Ƹü‘Â^ü°½KH Retains only the elements specified by the predicate, passing a mutableÁ¤þ½ reference to it.Á•¾úü›¾LI In other words, remove all elements e such that f(&mut e) returns false.Áüê¾LI This method operates in place, visiting each element exactly once in theÁü¹¿EB original order, and preserves the order of the retained elements.Á�Àú‡Àút�ÀÓížÀú\¤Àø½¬²ÀÑÔÊÀúüÐÀ;ÞÊüŽÁGD av.retain_mut(|x| if *x % 2 == 0 { *x *= 2; true } else { false });ÁüØÁ  assert_eq!(&av[..], [4, 8]);Á<ûÁ¥ÁT˜ÂŒ ŒåKŒÉƒqb—ŽŽ ¦Âb·É £Â‹“"ŒÉ ‹¦OÜÓ‹ŒÉ”ؘ"$êÂ
�™LŒÉ$«Â°ÍTµÂceìÑÃTØÃ>®�›‘�‘ƒÏ$éÔϼ÷Ã��œ’Â>“Ï>”ß>9Æ•¬ð$ð®´M9Æ•¬ð$ð’“”—$ãÃ~€‚,÷Ã>��¶Ð|–ÄD–Ä>��ýkŒÜÄTÜÄ>��ýküúÄ(8�›––�ƒÏ$ÿÄÁM—�"—”«Å$®ÅŽ ŽÁMƒq• ³Å•
—8´M$¸ÅüÙÍ)ü¦Ê1. Forces the length of the vector to `new_len`.ÁÚÊúlàÊ€íüðÊ63 * If `new_len` is greater than the vec's capacity.Á©Ëúl¯Ë×öü¿ËKH * This is a fully safe operation! The inactive memory already counts asÁü�Ì$! "initialized" by Rust's rules.Áü´ÌJG * Other than "the memory is initialized" there are no other guaranteesÁü�ÍA> regarding what you find in the inactive portion of the vec.Á<àÍ� �åKýkƒqb èÍb
˜™L$íͼÁ<óÍüòÕ.üÐÒ-* Splits the collection at the point given.Á€Óúü†Ó! * `[0, at)` stays in this vecÁüªÓ)& * `[at, len)` ends up in the new vec.ÁÖÓúlÜÓ€íŒìÓ * if at > lenÁ€Ôút†ÔÓí—Ôú\�Ôø½¬«ÔÑÔüÃÔ1ó�ô÷Ô let av2 = av.split_off(1);Áì˜Õ„³ü¸Õ! assert_eq!(&av2[..], [2, 3]);Á<ÜÕ¥ÁLùÕ� �åKýkåKb ƒÖb
™™L$ˆÖatÁŽÖüÍâÁüÌÚGD Creates a splicing iterator that removes the specified range in theÁü–ÛJG vector, yields the removed items, and replaces them with elements fromÁÔãÛ the provided iterator.Á€Üúü†ÜLI `splice` fuses the provided iterator, so elements after the first `None`Á„ÕÜ
are ignored.ÁèÜúlîÜ€íüþÜ+( * If the start is greater than the end.Áü¬Ý-‰�üÜÝ&# * If the provided iterator panics.Áü…ÞIF * If the new length would overflow the capacity of the array. BecauseÁüÑÞGD `ArrayVecSplice` adds elements to this vec in its destructor whenÁü›ß;8 necessary, this panic would occur when it is dropped.ÁÙßútßßÓí\ðßø½œþߌ¾ü”à1ó�üÈàB? let av2: ArrayVec<[i32; 4]> = av.splice(1.., 4..=6).collect();Áü�á1. assert_eq!(av.as_slice(), &[1, 4, 5, 6][..]);ÁüÁá,¤ƒðáúÄöá av.splice(.., None);Áü‘â#€„<·â¥Á4Ôâ‘ ‘åKÜ…íN§§�«Í>¬Û>­ð>®ƒ>ˆ*.½œ¡B‘™LÄ­Ä­FuseÁÆ­ù»>ŠÙkCçË¢;íNÉLb£›šœœ› æâb»† ÛâÍìíN Þâ̆”ÖãÇLíNäñãíNÈL¦Otþã
š™LÜ…íN$ëâò…,ñâƒ\ûâkmgi„›ä,¦äüôí6ü�êB? Remove an element, swapping the end of the v
$õ÷‘þ÷œÙþ’¢¢ëß ÞþåK£ 
ü¬„.üñþ0- Wraps up an array as a new empty `ArrayVec`.Á¤ÿúüªÿAÁ›îÿú|ôÿ ## ExamplesÁ†€úüŒ€B? This method in particular allows to create values for statics:ÁÑ€ú\×€ø½ä個Œü„�HE static DATA: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([0; 5]);ÁôÏ� assert_eq!(DATA.len(), 0);Á<ð�¥Áú�úü€‚85 But of course it is just an normal empty `ArrayVec`:Á»‚ú\Á‚ø½äÏ‚‹Œüî‚<9 let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);Áü­ƒ assert_eq!(&data[..], &[]);Á”σ data.push(42);Áüäƒ! assert_eq!(&data[..], &[42]);Á<ˆ„¥Á.\ž„„¹„™LåK¡¡
£™LÍ
96œ¯“’¥¥ëß ´“åK¦ 
ü••"üÇ“?< Returns the reference to the inner array of the `ArrayVec`.Á‰”úü�”K݆œÝ”±‡.\‡•D¢•” ”åK ”™L¤ «•¤
¦™L$¬•üñ˜Dü˜˜$! Splicing iterator for `ArrayVec`Áü½˜30 See [`ArrayVec::splice`](ArrayVec::<A>::splice)Á�?³¨’©šªª¨©ÍìçN �™óî ™™*çN,’™ùMíNÄœ™íNúMÕSt¥™çN³ܺ™“Nˆ*.½œ¡B«¬­®È‹™wy{}H4º™>§§ ³·R¤Ù™lÙ™>§§ýk”ñ™\ñ™>§§ýkt‡š\‡š>§§íNüššW³°’±š²±²°�†t¹šóî ­šî…,¦šý…Ä°šÔ… £š“N³´µúMûMÿM´µŸš,.TVLöš$ûš¯¯ÕSüš›%$�›• •“NÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÕS¯ ¢›¯
´³çNíN$§›üÍŸ-LП– –“NýkÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙýk¯ ÚŸ¯
µ³çNíN$ÛŸü³ n³·’¸š¹¹·¸�†t‘¡óî ¿ î…,ü ý…Ĉ¡Ô… ¼ “NºÄMº¸ BD´²¡µ¡— —“Nýk ¹¡
º³çNíN$º¡üü¡j³¼’½š¾½¾¼�†tÖ¢óî ˆ¢î…,Á¢ý…ÄÍ¢Ô… …¢“N�¢79ü좆³À’ÁšÂÂÀÁ�†tÌ£óî ø¢î…,·£ý…ÄãÔ… õ¢ŒMíNœÞ£“NÃ�MÃñ¢*,RTüƒ¤*L†¤˜ ˜“N݉¿ �¤¿
óçNíN$•¤ü¶¨S³Å’ÆšÇÅÆÇ�†tÕ¨óî ɨî…,¨ý…Ą̈Ô… ¿¨“NÈ�"È»¨BD”š©$�©™ ™“NƒqÄ ¢©Ä
ȳçNíN$§©ü”«/’ÊÊëß ™«õà,œ«åKËåËüÜ«&4ß«š šåK š¥OÉ æ«É
Ë™L$ë«ü›¬/’ÍÍëß  ¬õà,£¬åKÎâÎôã¬4欛 ›åK ›¥OÌ í¬Ì
ΙL$î¬ü–­0’ÐÐëß ›­õà,ž­åKÑ¢Ñôß­4â­œ œåK œ¥OÏ é­Ï
Ñ™L$ê­ü’®3’ÓÓëß —®õà,š®åKÔ¥ÔüÞ®*Tá®� �åK �¥OÒ ì®Ò
Ô™L$ñ®ü¡¯.’ÖÖëß ¦¯õà,©¯åK×ÒL×üà¯>4㯞 žåK—QƒqÕ¥ØØ ‹°ÕÍì—Q ê¯ÇL—Qäí¯—QÈL¦Otú¯
×™L—Q$�°ù$–°CEüÕ°&’ÚÚëß Ú°õà,Ý°åKÛëÛÄ®²ü”±41 The output has a length equal to the full array.Á˱úüѱ'$ If you want to select a length, useÁüû±0- [`from_array_len`](ArrayVec::from_array_len)Á$±²™LåKÙÙ
Û™LÍ
$¶²üǵ-÷OÝÅcÝü…¶9ˆ¶Ÿ ¡ Ÿ÷O   c cˆ¢cµ
 `£c¯^ `àB¤GS
¡Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ƒqŸÈŸÈ È  O˜éBLÜ Œ¶Ü
Ý$�± “¶üÈ·]8¢¥ß’àà¢ß‹Q+—QD›¸Íì‹Q зØ—Q,ÿ·³—Q<‡¸*‹Q|•¸�š Í·×Páâòóâ_aTª¸,¯¸ÞÞ÷Oü¸¹5üÙ¸NK The output has a length equal to that of the slice, with the same capacityÁ\ª¹ as `A`.ÁD»¹£ £–QÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
×P×P‘QòÞ ˹Þ
â8—Q‹Qž,Ĺüª¿4’ääëß ¯¿õà,²¿åKåÅLåüï¿>Lò¿—QåKã¥ææã�š ü¿’šäÿ¿¢štŒÀ
å™L—Qù$�À+-üÒÁ%ü‹ÁFC Iterator for consuming an `ArrayVec` and returning owned elements.Á£?’èèëß îÁõà,ñÁ²QÓ8D±¾éêë+-LüÁ$üÁ>ççþlL‰Â$‰Â>ççþl<–Â$–Â>çç™Lü¢Â"’ííëß §Âõà,ªÂ²Qîü¢Ã$üÉÂ<9 Returns the remaining items of this iterator as a slice.Á.\”ÃD©Ã¤ ¤²Q ¤¥Oì ²Ãì
î™L$³Ãü‘Ä4’ððëß –Äõà,™Ä²QüÉÄ/’òòëß ÎÄõà,ÑIJQóôõö÷øúMûMÿM€NƒN�Nõøôö÷OQLýÄ$‚Åññ¦Oü Å($£Å¥ ¥²QÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ²QúMñ ¨Åñ
ô™L$­Åü§Ç-LªÇ¦ ¦²Qˆ‹ñ ´Çñ
õ™L$µÇ¼½È,ÀȲQýkññ
ö™L$ÆÈü€É'$ƒÉ²QÚ«ññ
÷™L$ŒÉüÑÉ.Ôɧ §²Qýk�¨ñ ØÉñ
ø™L$Ýɹ ãÉüçÌ:’úúëß ìÌõà,ï̲Qûü�M�Mûü')ü²Í-LµÍ¨ ¨²QÚ«ù ¿Íù
û™L$ÄÍü°Ï6D³Ï© ©²QýkÚ«ù ¼Ïù
ü™L$ÁϹ ÇÏü°Ó8’þþëß µÓõà,¸Ó²QÿÄMÿ´ùÓüÓª ª²Qýký €Ôý
ÿ™L$�Ôü°ÔD’��ëß µÔõà,¸Ô¿c¦O,îÔ²Q‚Àc‚,.ü¬Õ9¯Õ«¬­ «²Q ¬ c cˆ¢cµ
 `£c¯^ `àB¤GS
­Ξ€ ³Õ€
‚™L$´Õ± ºÕüÒØ+’„„ëß ×Øõà,ÚØåK…†‡ÈLÉLÊL‡*,L‚Ù$‡Ùƒƒ¦Ol™ÙDžÙƒƒ²QüÔÙ$L×ÙåKåKÉLƒƒ
‡™L$áÙüÄÚ7뉒Š‰ŠÔ… ÍÚî…,ÐÚ±R‹Œ�ÈLÉLÊL�ÉÚ13L€Û$…Ûˆˆ ëÕSlŸÛD¤ÛˆˆÜlÜlIterMutÁßlµ ™làl
end_or_lenÁ™lál_markerÁ™lÚ½íDþïl%ëÕSüèÛ$LëÛ±R±RÉLˆˆ
�ëçN$õÛüªÜ3ë�’���Ô… ³Üî…,¶ÜöR‘’“ÈLÉLÊL“¯Ü13LâÜ$çÜŽŽ ëÕSlýÜD‚ÝŽŽÄlÄlIterÁÇlµ ™lÈl£·™lÉl¹·™lŒœjSžëÕSüÃÝ$LÆÝöRöRÉLŽŽ
“ëçN$ÐÝü�ÞD’••ëß †Þõà,‰Þµß¦O¦OL»ÞåK–·ß–13üÖÞ"ÙÞ®¯ ®åK ¯åK” ÜÞ”
–™L$ÝÞ¹
,ãÞüªß3’˜˜ëß ¯ßõà,²ß™¦OÛßåK!#üâßF’ššëß çßõà,êßíߦO¦OT�àåK›ïß›13ü¹àB\¼à°± °åK ±åKÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~ÅßÆßÇßGreaterÁÈßåºÝÈnûê7™ Èà™
›™L$Éà¹
,Ïàü¶á8’��ëß »áõà,¾áº¦OêáåKž»ž,.üÿá2‚â²³ ²åK ³åKšÀœ †âœ
ž™L$‡â¹
,�âüåâH8´’ ´ Ô… êâî…,íâµßÕSÕSL£ã·R¡·ß¡13ü¾ã Áãµ· µ·R  ·çNŸ ÄãŸ
¡8çN$Åã¹
,Ëãü‘äP8¸’££¸Ô… –äî…,™ä»ÃL×ä·R¤·ß¤&(üòä(õ乺» ¹·R º »ÔS¢ øä¢
Reference in New Issue Copy Permalink