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/libsmallvec-8fb808173b3f0087.rmeta
T

253 lines
111 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ÁserdeÁFVæ¸Û•IÄÀzÍ-9c8ce3cf08540cc3ÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á–�òÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥ÌýÝ°¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ�"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®Ë�Å�š-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ�’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLh�ž§Œaã¯>­�-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@T·-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥�-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib‚-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0Á serde_deriveÁ,w|êñ]ù¿¥­C£ð-975c43f96d83014eÁ
serde_coreÁ²€Ãb˜cÐòÅ�¾ÇÇ
-7a42419d8e43b208ÁÀ‘"‚$é!»writeÁŒï!Ìè!testsÁ,¨"‚$�"MallocShallowSizeOfÁœÄ&»malloc_size_ofÁÔ’& MallocSizeOfÁdÙ&»¼ "$MallocSizeOfOpsÁ|ç&»¼ EGioÁë(»òŒÎ( ManuallyDropÁd£)»drain_keep_restÁÜö(smallvec_inlineÁ|Ã@» const_newÁ¬Ù? DrainFilterÁ\Õm» drain_filterÁÄñk SmallVecDataÁd³ »CŒ™ SpecFromÁDá•»ªÔ¾•ªtΖ»ªÔ­– arbitraryÁL�—»– ¬å–
impl_arrayÁTÑî»ÄÔ¦îä¥î
BorrowDecoderÁlöù» impl_bincodeÁÄÃùDecodeÁ4…ú»ù  DecoderÁ<�ú»ù :<ReaderÁ4œú»ù UWEncodeÁ4¯ú»ù prEncoderÁ<·ú»ù ŒŽWriterÁ4Çú»ù §© DecodeErrorÁ\Üú»ù ÇÉ EncodeErrorÁ\éú»ù çé BorrowDecodeÁdûú»ù  í¤ 
  
 !"#$%&'()*+,smallvecÁdebug_unreachableÁExtendFromSliceÁ2¥2extend_from_sliceÁ5¥5¢8×:÷
infallibleÁ<¥ layout_arrayÁ>¥> 
deallocateÁA¥DrainÁC'aÁC¥C
tail_startÁCtail_lenÁCùCÁJ¼J¥J×N¼N¥Q¼Q¥T¼T¥T›Tó X T size_hintÁ[¼[¥[ next_backÁ^ `¼`¥`‘ d¼d¥
g¼g¥gã» k’kInlineÁm
mˆkHeapÁpµ p‘ s’sÝs
inline_mutÁs from_inlineÁsemptyÁs into_inlineÁsheapÁsheap_mutÁs from_heapÁ }’
’SmallVecÁ�’�capacityÁ�dataÁ…’…æ …
with_capacityÁ…from_vecÁ…from_bufÁ…from_buf_and_lenÁ…from_buf_and_len_uncheckedÁ…set_lenÁ…inline_capacityÁ… inline_sizeÁ…‘…is_emptyÁ…¿…tripleÁ…
triple_mutÁ…spilledÁ…drainÁ–£–…pushÁ…popÁ…appendÁ›“…growÁ…try_growÁ…reserveÁ…reserve_one_uncheckedÁ… try_reserveÁ…
reserve_exactÁ…try_reserve_exactÁ…
shrink_to_fitÁ…truncateÁ…as_sliceÁ… as_mut_sliceÁ… swap_removeÁ¨ …clearÁ…removeÁ…insertÁ… insert_manyÁ­š­ DropOnPanicÁ¯¥¯¹¯skipÁ¯‘­´¥´ã…into_vecÁ…into_boxed_sliceÁ…
into_innerÁ…retainÁº—…
retain_mutÁ¼—…dedupÁ¾ …dedup_byÁÀ—… dedup_by_keyÁ—œ … resize_withÁÆ—…from_raw_partsÁ…as_ptrÁ…
as_mut_ptrÁË’Ë
from_sliceÁËinsert_from_sliceÁˢВÐresizeÁÐ from_elemÁÔ’ÔåÔ´Ø’ØÛ’ÛÉÞ’Þas_mutÁá’áborrowÁä’ä
borrow_mutÁç’ç serializeÁé¤ë'deÁë’ë deserializeÁî•SmallVecVisitorÁð’ðphantomÁóÞ ó’óValueÁó expectingÁó visit_seqÁø“øû¼û’û÷ÿ’ÿ÷‚’‚÷…’…š…°…ÖŠ’ŠšŠ×Ž’Ž¢ ‘’‘ù“š!•’•extendÁ—š"™’™×#œ’œ>$Ÿ’Ÿã%¢’¢ƒ¢†&¦’¦“¦�'ª’(¬’¬ï
)¯’¯‹*²’²§´™+’IntoIterÁ¸’¸Ï¸currentÁ¸þ,½’½×-À’Àƒ.Ã’Ãã/Æ’Æ›Æó ÆÛ0Ë’Ëý1Î’2Ð’3Ò’ÒÛÒë4Ö’Ö­%Ö›Öê5Û¼Û’Û­%Û›Ûê6á¼á’á­%á›áêMç›ç™ SetLenOnDropÁê¼ê‘ê local_lenÁ7î¼îæ îgetÁî
increment_lenÁ8ó¼óã9ö¥öŸö ö›ö™
ToSmallVecÁü’ü to_smallvecÁ:ÿ’ÿÜ) ConstNonNullÁ‚
‚¥‚ˆ;†¥†æ †•<Š¥Šƒ=�¥CollectionAllocErrÁ�CapacityOverflowÁ�
�AllocErrÁ’layoutÁ>”×4
4
7
7
9
9
9
M
M
M
X
Z
^
c
j
u
v
z
{
�
�
�
‘
’
“
”
•
–
™
š
›
›
�
ž
Ÿ
 
¡
¢
£
¤
¥
¦
§
¨
ª
«
¬
­

º
º
¼
¼
¾
À
À
À
Â
Â
Æ
É
Ê
Í
Î
Î
Ï
Ï
Ò
×
Ú
Ý
à
ã
æ
é
÷
÷
÷
‰
�
�
�
—
›
›
›
¡
¤
¥
¥
©
©
®
®
±
±
´
´
¿
¿
¿
Â
Å
É
Ê
Í
Ô
Õ
ñ
ò
õ
þ
�
Œ
•
•
•
2çü2ªBªBö­BbufÁ÷<®B‘÷<9)
-ÜnL¥çEçEèEGlobalÁ ¿±‡§í#¾1¿c��‘€+’�+“­+E”BÂ�£DÄcú1éú1ûØûØüØ LayoutErrorÁ :ð¨?¢©¿cCC°FÌGÝHùIÁ cÓS[¼¥� „3Ìì„3ùM„3ŒM„3ÃM„3òP„3Œ"„3Ììkmnãoˆpûqµ r‘®®ÇU ‚ãV’� §4Œ"¯¯Û±¹²þ³‘kÈüç#«¾1é!��§ƒ¿„Ï@dÕŠÔÁvöó4ö!×5à×5
ó4èã×5¦6 ×5¦6£×5¦6ÙA×5û;��§ƒ¿„Ï@dÕŠÔÁvö’Þ Ì<ðð‹!òª!'uÉÖx¡7Þ éé6 ¼
¡7èé×5ªBªBö­B”0÷<®B‘÷<9)
-ÜnL§6Ä1é×5ó4Ù¢×5š³"×5è82×5§6ÃL×5§6ÐL×5§6¿c×5³×5Œ"×5Ø×5µß×5��§ƒ¿„Ï@dÕŠÔÁvö“™×5íß×5×5º×5še×5Ìì×5¿c¸¸­%ºÏ»Í%¼þsg�uÐ;Æ•ó4ØÐ:Œ"Ð:ùMÐ:ŒMÐ:ÃMÐ:òPÐ:ÇL×5ÇL ¼é6ÇL ¼é6Œ"êê�(ì‘íÁ(~&ø1àƒ}¼ç¾1Ÿü¦6ó4Ø‚‚ƒ‚*…ˆ Ü ¿–c…¾1Š ç<5ªBŽ�”�JC™�½¸8�:�û�ÿ�‚�NCkQC}k¶�TCƸ[C˸`CθdCиgC´¯Ÿ�øóêÔ�Ø�Û�Þ�á�ä�ç�ë�óð…�Š�‘�•�œ�¢�À¸Š‚¦�ª�¬�¯�²�Ö�Û
á
öÿ �‚2î¿c
Äcé� Ìì
ùMŒM ÃM òP Œ" é!!ö!àã £ÙAû;Ì<Ù¢³"ÃLÐL³Øµß™íߺšeÇLçüŠ 4¥´ kó4n'§42ÑÛÑÛ MaybeUninitÁÓÛuninitÁÝÔÛ»ÝÍõƒ«%9ó4ˆ�´³ö ‚¾1ƒ)ç<4‰‰§‹‰ ïíe¼îËè¿*¾1ip2<>ACk�ð¸çêü‚ƒ�í¤,×! 4Ø"èØ LayoutErrÁLà"Þ‚BoxÁþ"�Á�#÷< Á ö™#ªB
Y4²#  ZLº#£
‹Ð#‹×ß# `Ž$õ#šeŽ e‘4û#¢eunreachable_uncheckedÁ¬”$ ‘ repeatÁ4¼$ �K‹dÄ$ÃL
FusedIteratorÁlÒ$òP˜dá$ÇLíú$ëŒA\Ž%ÑÛ­
$«% ¹,±%�£ RangeBoundsÁ\¸%¤#µ $Ö%“ §<Ü%‰!ž$ø%‰f#ÚTþ%“k$ DeserializeÁ\ª'û;' DeserializerÁd·'ˆ<( SeqAccessÁLÅ'‹=)VisitorÁ<Ð'Ì<* SerializeÁLä'ÙA, SerializeSeqÁdï'’B-
SerializerÁTý'ÜA. PhantomDataÁ\º(• /¦I– /ÞDž30ü­ç”ü­b_ Small vectors in various sizes. These store a certain number of elements inline, and fall backÁü�^[ to the heap for larger allocations. This can be a useful optimization for improving cacheÁüï\Y locality and reducing allocator traffic for workloads that fit within the inline buffer.ÁÌú¼Ð ## `no_std` supportÁèúüìKH By default, `smallvec` does not depend on `std`. However, the optionalÁü¸NK `write` feature implements the `std::io::Write` trait for vectors of `u8`.Áü‡>; When this feature is enabled, `smallvec` depends on `std`.ÁÆúÄÊ ## Optional featuresÁãú|ç ### `serde`Á÷úüû^[ When this optional dependency is enabled, `SmallVec` implements the `serde::Serialize` andÁüÚ  `serde::Deserialize` traits.Áûú|ÿ ### `write`Á�úü“\Y When this feature is enabled, `SmallVec<[u8; _]>` implements the `std::io::Write` trait.Áüð>; This feature is not compatible with `#![no_std]` programs.Á¯ ú|³ ### `union`Áà úüÇ (% **This feature requires Rust 1.49.**Áð úüô [X When the `union` feature is enabled `smallvec` will track its state (inline or spilled)ÁüÐ
\Y without the use of an enum tag, reducing the size of the `smallvec` by one machine word.Áü­ MJ This means that there is potentially no space overhead compared to `Vec`.Áüû _\ Note that `smallvec` can still be larger than `Vec` if the inline buffer is larger than twoÁ”Û  machine words.Áî úüò [X To use this feature add `features = ["union"]` in the `smallvec` section of Cargo.toml.ÁüÎ
.+ Note that this feature requires Rust 1.49.Áý
úü�ZW Tracking issue: [rust-lang/rust#55149](https://github.com/rust-lang/rust/issues/55149)ÁÜúÄà ### `const_generics`Áùúüý(% **This feature requires Rust 1.51.**Á¦úüª`] When this feature is enabled, `SmallVec` works with any arrays of any size, not just a fixedÁ”‹ list of sizes.Ážúœ¢ ### `const_new`Áúüº(‘Yãúüç³ This feature exposes the functions [`SmallVec::new_const`], [`SmallVec::from_const`], and [`smallvec_inline`] which enables the `SmallVec` to be initialized from a const context.ÁÄž For details, see theÁü·ZW [Rust Reference](https://doc.rust-lang.org/reference/const_eval.html#const-functions).Á’ú´– ### `drain_filter`Á­úü±fc **This feature is unstable.** It may change to match the unstable `drain_filter` method in libstd.Á˜úüœ\Y Enables the `drain_filter` method, which produces an iterator that calls a user-providedÁüù\Y closure to determine which elements of the vector to remove and yield from the iterator.ÁÖúÌÚ ### `drain_keep_rest`Áôúüøif **This feature is unstable.** It may change to match the unstable `drain_keep_rest` method in libstd.Áâúüæ0- Enables the `DrainFilter::keep_rest` method.Á—úÄ› ### `specialization`Á´úü¸TQ **This feature is unstable and requires a nightly build of the Rust toolchain.**Á�úü‘]Z When this feature is enabled, `SmallVec::from(slice)` has improved performance for slicesÁüï^[ of `Copy` types. (Without this feature, you can use `SmallVec::from_slice` to get optimalÁüÎ" performance for `Copy` types.)ÁñúüõZW Tracking issue: [rust-lang/rust#31844](https://github.com/rust-lang/rust/issues/31844)ÁÐú¤Ô ### `may_dangle`ÁéúüíT“cÂúüÆ_\ This feature makes the Rust compiler less strict about use of vectors that contain borrowedÁü¦$! references. For details, see theÁüËYV [Rustonomicon](https://doc.rust-lang.org/1.42.0/nomicon/dropck.html#an-escape-hatch).Á¥úü©ZW Tracking issue: [rust-lang/rust#34761](https://github.com/rust-lang/rust/issues/34761)Á2<>ACk�ð¸çêü‚ƒ�í·¤¸ ·èØ°C­Þ‚ÍC©�Á¨÷< Áº ö¨ªB
Y§  Z¦£
‹¥‹×¤ `Ž£šeŽµ e‘£¢eœE� ‘ ÄE† �K‹…ÃLðEwòP˜vÇLíuëŒAtÑÛ­
s ¹r�£ñFf¤#µ e“ §d‰!žc‰f#Úb“k$ÛGVû;'ùGIˆ<(˜H?‹=)´H7Ì<*ÎH-ÙA,êH ’B-‰IÜA.¦I • /¦I– /Þ 0oru´Æ!ldÉ"cfLOŒð"?,‡#36D”#d£#LÊ#ùLÙ#íTè#áäÂÅüˆ$!¥T¯$“–†‰lo_bLô$V´ƒ%JLŸ%=¥%14LÊ%Ð%\ê%ú,ð%îñ,˜'|˜'ÞáÅȯ²›žü˜'IŠ�qtZ]̬(F¬‘3ü²)41 Creates a [`SmallVec`] containing the arguments.Áç)úüë)[X `smallvec!` allows `SmallVec`s to be defined with the same syntax as array expressions.ÁüÇ*&# There are two forms of this macro:Áî*úüò*@= - Create a [`SmallVec`] containing a given list of elements:Á³+ú<·+ ```Áü¿+)& # use smallvec::{smallvec, SmallVec};ÁŒé+ # fn main() {Áüû+30 let v: SmallVec<[_; 128]> = smallvec![1, 2, 3];Áį, assert_eq!(v[0], 1);ÁÄÈ, assert_eq!(v[1], 2);ÁÄá, assert_eq!(v[2], 3);Á<ú, # }Á<‚-ËtŠ-úüŽ-:7 - Create a [`SmallVec`] from a given element and size:ÁÉ-ú<Í-ËtüÕ-)ÜtŒÿ-Žuü‘./, let v: SmallVec<[_; 10]> = smallvec![1; 3];ÁüÁ.1. assert_eq!(v, SmallVec::from_buf([1, 1, 1]));Á<ó.Èv<û.Ëtƒ/úü‡/HE Note that unlike array expressions this syntax supports all elementsÁüÐ/KH which implement [`Clone`] and the number of elements doesn't have to beÁ|œ0 a constant.Á¬0úü°0NK This will use `clone` to duplicate an expression, so one should be carefulÁüÿ0JG using this with types having a nonstandard `Clone` implementation. ForÁüÊ1OL example, `smallvec![Rc::new(1); 5]` will create a vector of five referencesÁüš2RO to the same boxed integer value, not five references pointing to independentlyÁœí2 boxed integers.Á(|�3é §3 Ð7 â3 ï3 ã38oneÁä3, è38à é3& ê38›$ë3*ñ3 ô3 û37‰¬4õ3% ü3 ‚4 ƒ4*…4 ˆ4 ®4, ’48,“4'˜48§Dš4'¢48æ ¤4 §4 ¨4% ¯4 µ4 É4 , ¶48elemÁ$·4& »48›$¼4% À4, Â48¹ Ã4& Ä48›$Å4*Ë4 Î4 …5 Ï4 „5, Ù48,Ú4'ß48§Dá4'é48ŽLë4 ô4 þ4, õ48Á$ö4$ ú4, ü48¹ ý4% †5 Œ5 ž5, �5 Ž5 –5, �58à �5& ‘58›$’5$ —5 ˜5, ™5 š5 œ5$ ›5- �5* 5 £5 Í7 ¤5 Ì78®58ü,²5 ¸57ˆ¬4º5, Á5 Â5 ß5 Ã5, Å58,Æ5'Ë58ÞDÍ5 Õ5 Ö5 Þ5 ×58ç}Ø5, Ü58à Ý5 à5% á58ë58ï58Áó5 ÷5, ù58,ú5'ÿ58§D�6'‰68æ ‹6 Ž6 �6% �68š68ü,�6£68Á¦6 ©68„\ª6 µ6 ¶6 ¸6 ð6, Æ6 Ç6 Õ68ÁÈ6 Ë68€$Ì6 Ð6 Ó6, Ñ68à Ò6% Ô6
Ö68Áä68$ò6 ÷6 Æ7, …78,†7'‹78§D�7'•78„D—7 Ÿ7 ¼7,  78,¡7'¦78¤,¨7'­78Á¯7 ²7 ³7 »7, ´7 µ7 ¹7, ¶78à ·7$ ¸7 º7% Î7ô™D»CŒ„DœƒDôúCŒ¦D ¸D šF ¾D ¿D*ÁD ÄD �E8íŒÎD ßD àD ûD7entered unreachable codeÁÔáD% ‚E ˆE �E, ‰E8° ŠE& ‹E8›$ŒE*’E •E —F8ŸE8â¢E ¥E ¦E ·E8�„§E ¹E ÛE8Á
,ÇE ÌE ÍE ÐE, ÎE8° ÏE% ÑE8$ÝE âE ‘F8œE¬ðE …F †F% ‡F% ˜Fä¬Jü�FMJ Trait to be implemented by a collection that can be extended from a sliceÁëFútïF ## ExampleÁþFú\‚G ```rustÁüŽG.+ use smallvec::{ExtendFromSlice, SmallVec};Á½GúüÁG63 fn initialize<V: ExtendFromSlice<u8>>(v: &mut V) {ÁüøG&# v.extend_from_slice(b"Test!");Á,ŸH }Á¥Húì©H let mut vec = Vec::new();ÁÌÇH initialize(&mut vec);ÁüáH assert_eq!(&vec, b"Test!");Á�Iúü…I30 let mut small_vec = SmallVec::<[u8; 8]>::new();Áü¹I initialize(&mut small_vec);ÁüÙI-* assert_eq!(&small_vec as &[_], b"Test!");Á<‡JËt4•JlžJ|¶J2¥323Îìü¬J�ÍìÒ3 ÆJ2ß‘)ß‘/444&(ü�K-üÏJ96 Extends a collection from a slice of its element typeÁŒ�K–— –ç‘ —
Ò32 ¢K2
4ç‘Ò3$§K¹
,­KüÓK,¥66Íì¾1 ØKؾ1,ÛK�1747 ü†L,Œ‰L˜™ ˜�1 ™
¾15 ›L5
7¾1$ L¹
,¦Lü¹O(ú19Åc9üèO8ëOš›œ šú1 › c cˆ¢cµ
 `£c”0 `àB¤GS
œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBL8 ïO8
9$ðO± öOüóP+ú1;ë;ì¥Q$¨QÉ2ú1::
; ­QüûQ<TþQÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¾1ú1¾1¥==ˆ” ‰R
<¾1� 4ŒRü¥UBd¨UÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
èØèØ éØ™²‚êØŸ²‚ªë¥CHÈú1¥??ˆ” µU
>¾1¹ ¸U³W><closure_kind>Á@<closure_signature>Á@<upvars>Á@@>@¾1É2ú1üàW9TêWŸC¥BBˆ” õW
A¾1µ øW¿D‰Xü‡[#ü×YRO An iterator that removes the items from a `SmallVec` and yields them by value.ÁªZúü®Z)& Returned from [`SmallVec::drain`][1].ÁØZúüÜZ*' [1]: struct.SmallVec.html#method.drainÁ,’[¼D¥EDEó‘ œ[Ò3¼Ÿ[çÒ3,¤[Ò3輧e„3 cÓS[FGHIj˜[Z\DŒ±[T±[CC|È[DÈ[CCôÝ[$Ý[CCÄlÄlIterÁÇlµ ™lÈl
end_or_lenÁ™lÉl_markerÁ™lŒœjSž¼Œ Ì�\�\CC‰‰§‹‰ ïíe¼îËè¿*��§ƒ¿„Ï@dÕŠÔÁvöÒ3üŸ\R¼K¥LKLó‘ ¨\ퟫ\ûŸ,°\¿cŒ Tæ\„3MÀcM¤\68Küø\8û\�žŸ �„3 ž c cˆ¢cµ
 `£c”0 `àB¤GS
ŸÍ–J ÿ\J
M¼Ò3$€]± †]ü�^6¼O¥PPOó‘ ‘^� Ò3$”^ûŸ,›^„3�^$&ü»^6¼R¥SRSó‘ Ë^ÌìÒ3$Î^ûŸ,Õ^„3Ç^%'üö^1¼U¥VVUó‘ ÿ^ퟂ_ûŸ,‡_„3WXZúMûMÿMXZû^57UL®_$³_TTŒ üÖ_%$Ù_   „3Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙŒ T Þ_T
X¼Ò3$ã_\µ`X†›Yž›Y»›YYXYÒ3 Œ Œ üû`-Lþ`¡ ¡„3Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙT ˆaT
Z¼Ò3$‰aüÒa<¼\¥]\]ó‘ ÛaíŸÞaûŸ,ãa„3^�M^×a&(\ü£b*L¦b¢ ¢„3•¨[ °b[
^¼Ò3$µb\Œc^†›_ž›_»›__^_Ò3Ø©üÂc5¼a¥babó‘ ËcûŸ,Îc„3cÄMcÇc ´Œd�d£ £„3` “d`
c¼Ò3$”düÆd1¼e¥fefó‘ ÏdûŸ,Òd„3Ëdüüd-¼h¥ihió‘ …e퟈eûŸ,�e„3j�"j�e&(h”°e$³e¤ ¤„3g ¸eg
j¼Ò3$½e܃´»CŒî³œí³ôä³dˆ´’llÍìó4 •´çó4,˜´§4®®ÇU ‚ãVmnpno€B§4qrBDJ J kk
nó4J J €B§4kkŒ²t¬´kk€B$Œµkk§4¬æ¶æ¶kk‰‰§‹‰ ïíe¼îËè¿*§6T…·…·kkôع»CŒÃ¹œÂ¹ô¹¹’ttœ± ݹ­±,๧4uvwxyz{|!#ü‹º04•º¥ ¥§4‚‚ƒ‚*…ˆ Ü ¿–c…§6s œºs
uó4$�ºüý»3T‡¼¦ ¦§4‘³s ’¼s
vó4$—¼üï½9\ò½€B§4ss
wó4Ý4þ½쳿,¶¿§4ss
xó4üÚÁ-\äÁ§4€Bss
yó4$ðÁü’Ã7$œÃ§ §§4÷´s ¡Ãs
zó4$¢ÃüõÄ?DÿĨ ¨§4‘³ ¨s ˆÅs
{ó4$�ÅüÑÆBLÔÆ‘³§4ss
|ó4µ ÞÆ‘õÆüÇÇ5’~~œ± ÓÇ­±,ÖÇÌìó4$Þǧ4"$ü€È5’€€œ± ŒÈ­±,�È� ó4$—ȧ4!#ìôÐüºÈLI A `Vec`-like container that can store a small number of elements inline.Á‡Éúü‹É[X `SmallVec` acts like a vector, but can store a limited amount of data inline within theÁüçÉ`] `SmallVec` struct rather than in a separate allocation. If the data exceeds this limit, theÁüÈÊWT `SmallVec` will "spill" its data onto the heap, allocating a new buffer to hold it.Á Ëúü¤Ëc` The amount of data that a `SmallVec` can store inline depends on its backing store. The backingÁüˆÌ^[ store can be any type that implements the `Array` trait; usually it is a small fixed-sizedÁüçÌ[X array. For example a `SmallVec<[u64; 8]>` can hold up to eight 64-bit integers inline.ÁÃÍútÇÍî‹ÖÍú\ÚÍ‘ŒÜæÍ use smallvec::SmallVec;Áü‚ÎIF let mut v = SmallVec::<[u8; 4]>::new(); // initialize an empty vectorÁÌÎúüÐÎHE // The vector can hold up to 4 items without spilling onto the heap.Áœ™Ï v.extend(0..4);ÁÜ­Ï assert_eq!(v.len(), 4);ÁÔÉÏ assert!(!v.spilled());ÁäÏúüèÏ>; // Pushing another element will force t
elements.ÁÐÙúüØÙQN Will create a heap allocation only if `n` is larger than the inline capacity.Á®Úú<¶ÚËtìÂÚ # use smallvec::SmallVec;ÁäÚúüìÚ<9 let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);Á­ÛúÔµÛ assert!(v.is_empty());ÁüÔÛ! assert!(v.capacity() >= 100);Á<úÛËtl›Ü×5……
ˆó4¹ ©Üü¹à5ü“Ý52 Construct a new `SmallVec` from a `Vec<A::Item>`.ÁÍÝúüÕÝ`] Elements will be copied to the inline buffer if `vec.capacity() <= Self::inline_capacity()`.ÁºÞú\ÂÞ‘ŒÜÒÞÌÀòÞúüúÞ" let vec = vec![1, 2, 3, 4, 5];Áü¡ß>; let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);Áäßúüìß.+ assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);Á<ŸàËtDÀà�8×5……
‰ó4ÁÍàü¾ë&üéè@= Constructs a new `SmallVec` on the stack from an `A` withoutÁ¬®é copying elements.ÁÈéú\Ðé‘ŒÜàéÌÀ€êúôˆê let buf = [1, 2, 3, 4, 5];Áü«ê96 let small_vec: SmallVec<_> = SmallVec::from_buf(buf);Áéêúüñê.³Ï<¤ëËtDÅëó4×5……
Šó4”0Îëü­ð:üôì@ÁÐü¹íA> copying elements. Also sets the length, which must be less orÁüÿí equal to the size of `buf`.Á£îú\«î‘ŒÜ»îÌÀÛîúüãî'$ let buf = [1, 2, 3, 4, 5, 0, 0, 0];Áü�ïDA let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);ÁØïúüàï.³Ï<“ðËt„´ðó4×5……
‹ó4”0Åð‘Íðü�öXüìñ@ÁÐü±òC@ copying elements. Also sets the length. The user is responsibleÁüùò)& for ensuring that `len <= A::size()`.Á§óú\¯ó‘ŒÜ¿óÌÀôßó use std::mem::MaybeUninit;Á‚ôúüŠô'ùÔü¶ô)& let small_vec: SmallVec<_> = unsafe {ÁüäôFC SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)Á4¯õ };ÁºõúüÂõ.³Ï<õõËtÔ�ö€B×5……
Œó4”0¸ö‘ÍöüÑù0üß÷  Sets the length of a vector.Á„øúüŒøEB This will explicitly set the size of the vector, without actuallyÁüÖøGD modifying its buffers, so it is up to the caller to ensure that theÁü¢ù*' vector is actually the specified size.Á<ßù© ©×5… çù…
�ó4$ìùnew_lenÁ<òùì­û|°û……
Žó4ü­‚"üÜ�>; The maximum number of elements this vector can hold inlineÁ\´‚ª ª×5… À‚…
�ó4$Á‚Ô¿ƒüý‚/, The number of elements stored in the vectorÁƃ« «×5… ʃ…
�ó4$˃ô»„üÿƒ)& Returns `true` if the vector is emptyÁD„¬ ¬×5… Ë„…
‘ó4$Ì„üÒ…üÿ„@= The number of items the vector can hold without reallocatingÁDÙ…­ ­×5… â……
’ó4$ã…üÀ‡94Ç® ®×5÷´… ʇ…
“ó4$ˇüØŠATÛŠ¯ ¯×5‘³ ¯… 抅
”ó4$ëŠì÷Žü“ŽQN Returns `true` if the data has spilled into a separate heap-allocated buffer.Á<þŽ° °×5… †�…
•ó4$‡�üú“]üÒ�NK Creates a draining iterator that removes the specified range in the vectorÁü¥�! and yields the removed items.ÁË�úüÓ�EB Note 1: The element range is removed even if the iterator is onlyÁü�‘.+ partially consumed or not consumed at all.ÁБúüØ‘KH Note 2: It is unspecified how many
# ExampleÁÖ¶ú<Þ¶Ëtüê¶)& # use smallvec::{SmallVec, smallvec};Áü˜·85 let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];ÁüÕ·85 let mut v1: SmallVec<[u8; 32]> = smallvec![4, 5, 6];Á¼’¸ v0.append(&mut v1);Áü®¸(% assert_eq!(*v0, [1, 2, 3, 4, 5, 6]);ÁÄÛ¸ assert_eq!(*v1, []);Á<ø¸Ët4‹¹´µ ´×5 µÔ9…“œœ •¹…ÍìŒ: ’¹çŒ:¬Î¹Œ:è§6tÔ¹
›ó4Œ:$š¹¹
, ¹CEüä»&ü›ºEB Re-allocate to set the capacity to `max(new_cap, inline_size())`.Áåºúüíº85 Panics if `new_cap` is less than the vector's lengthÁüª»52 or if the capacity computation overflows `usize`.Á$ë» ×5… ð»…
�ó4$õ»new_capÁ<û»üÒ½LüüEÌõ�½úü•½8©öDÙ½· ·×5Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ú1… â½…
žó4$ç½ù÷<í½üŸÍ,ü»ËC@ Reserve capacity for `additional` more elements to be inserted.ÁƒÌúü‹Ì;8 May reserve more space to avoid frequent reallocations.ÁËÌúüÓÌ96 Panics if the capacity computation overflows `usize`.Á<¦Í¸ ¸×5… ®Í…
Ÿó4$³Í
additionalÁT¹ÍüúÎ#¬ýι ¹×5… “Ï…
 ó4$˜Ïü¼ÒRü¬ÑCüùôÑúüüÑ;×ú\ÃÒº º×5çù… ÏÒ…
¡ó4$ÔÒ»üTÚÒü†Ø2üôÖOL Reserve the minimum capacity for `additional` more elements to be inserted.ÁÈ×úüÐ×1. Panics if the new capacity overflows `usize`.Ál�Ø» »×5… ›Ø…
¢ó4$ Ø»üT¦ØüÑÙXüýØOÍþŒØÙ¼ ¼×5çù… êÙ…
£ó4$ïÙ»üTõÙü…ÞüÎÜ:7 Shrink the capacity of the vector as much as possible.Á�Ýúü•ÝZW When possible, this will move data from an external heap buffer to the vector's inlineÁdôÝ storage.ÁlŒÞ½ ½×5… šÞ…
¤ó4$ŸÞüŠå&üÀâOL Shorten the vector, keeping the first `len` elements and dropping the rest.Á”ãúüœãQN If `len` is greater than or equal to the vector's current length, this has noÁ\òã effect.Á‚äúüŠäQN This does not re-allocate. If you want the vector's capacity to shrink, callÁüàä%" `shrink_to_fit` after truncating.ÁD‘å¾ ¾×5… šå…
¥ó4$Ÿå‘¥åüÓè$üôç2/ Extracts a slice containing the entire vector.Á«èúܳè Equivalent to `&s[..]`.ÁDÚè¿ ¿×5 ¿¦6… ãè…
¦ó4$äèüõé0ü’é2/ Extracts a mutable slice of the entire vector.ÁÉéúüÑé Equivalent to `&mut s[..]`.ÁdüéÀ À×5 À¦6… ‰ê…
§ó4$Žêü”ì6üÀêOL Remove the element at position `index`, replacing it with the last element.Á”ëúüœë1. This does not preserve ordering, but is O(1).ÁÒëúüÚë'$ Panics if `index` is out of bounds.Á\›ìÁ Á×5§6… §ì…
¨ó4$¬ìÖ,²ì½í¨†›©ž›©»›©©¨©ó4§6¼ªîüïí(% Remove all elements from the vector.Á,±î Â×5… ·î…
ªó4$¼îüŒð1üéî\Y Remove and return the element at position `index`, shifting all elements after it to theÁLÊï left.ÁØïúüàï'ªŒ4“ðà Ã×5§6… šð…
«ó4$ŸðÖ,¥ðü¤ô8üŸóWT Insert an element at position `index`, shifting all elements after it to the right.Áûóúäƒô Panics if `index > len`.Á4«ôÄ Ä×5§6… ²ô…
¬ó4$·ôÖ,½ôelementÁ<Ëôü�üYü û\Y Insert multiple elements at position `index`, shifting all following elements toward theÁL�ü back.Á\–üÅ Å×5è8…š®® Ãü…Íìè8 ¢üÇLè8ä¥üè8ÈL§6t²ü
­ó4è8$ÈüÖ,ÎüiterableÁDÜüTV¬úŽ\��¥°°ˆ” ��Š5kÈüç#«±²³%'lž�,ž�¯¯ ¾1”¹�$¹�¯¯�£�£¹ƒ£¹„£þ-'ºˆÉ¬gT����¯¯ü¯�¥µµˆ” ´�Š5¶�"”Ý�$à�Æ ÆŠ5´ å�´
¾1$ê�üŽ”)ü““da Convert a `SmallVec` to a `Vec`, without reallocating if the `SmallVec` has already spilled ontoÁlü“
the heap.ÁD•”×5�8……
·ó4$¢”üƘ/ü†—fc Converts a `SmallVec` into a `Box<[T]>` without reallocating if the `SmallVec` has already spilledÁ”ñ— onto the heap.Áˆ˜úü�˜1. Note that this will drop any excess capacity.Á„͘×5��žÍC¡ˆˆ¢‰ˆl }.xϦ6Ä1……
¸ó4$Þ˜üÜ›*ü®™QN Convert the `SmallVec` into an `A` if possible. Otherwise return `Err(Self)`.Á„šúüŒšqn This method returns `Err(Self)` if the `SmallVec` is too short (and the `A` contains uninitialized elements),Áü‚›UR or if the `SmallVec` is too long (and all the elements were spilled to the heap).ÁTã›×5Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ó4×5……
¹ó4$î›üÚ Büáž96 Retains only the elements specified by the predicate.ÁŸŸúü§ŸNK In other words, remove all elements `e` such that `f(&e)` returns `false`.ÁüúŸIF This method operates in place and preserves the order of the retainedÁlÈ úÈ4á È È×5—…—»» ˆ¡…Íì¤ è Ç“"¤ ǧ6Üë Ç¤‘¥˜"$‚¡
ºó4¤$�¡± —¡bdüÅ¥Bü¸£9”¡ö£úüþ£LI This method is identical in behaviour to [`retain`]; it is included onlyÁüϤHE to maintain api-compatibility with `std::Vec`, where the methods areÁüœ¥$! separate for historical reasons.ÁTÌ¥Ê Ê×5¤…—½½ ÷¥…ï¤ ×¥É“"¤ ɧ6Üڥɤר˜"$ñ¥
¼ó4¤$ü¥± ‚¦bdüܦFü¬¦+( Removes consecutive duplicate elements.Á,ã¦Ë Ë×5… 馅µß§6§6”�§
¾ó4$î¦4¿§¾†›¿ž›¿»›¿¿¾¿ó4 §6 §6ü¬¨qüÚ§MJ Removes consecutive duplicate elements using the given equality relation.ÁD³¨Î Î×5¤…—ÁÁ ¿¨…ï¤ ¼¨ÌÍ“"¤ ̧6 ͧ6üó¨)Ìͤ¦­˜"$˜©
Àó4¤$Ĩ same_bucketÁ\Ψ„†ü¼¯xüý®:7 Removes consecutive elements that map to the same key.ÁdïÐ Ð×5¤…—ÃœÄÃÄ Ö¯…ï¤ ЯÍìœ Ó¯Ï“"¤ ϧ6Ä‚°Ï¤ý¯˜"ᯠ™°µßá¯á¯d§°
Âó4¤á¯$Û¯keyÁ寕—Ž�4Ѱ†›Åž›Å»›ÅÅÂÅó4¤á¯¯« ¤ü£º_üö°HE Resizes the `SmallVec` in-place so that `len` is equal to `new_len`.Áñúü˱_\ If `new_len` is greater than `len`, the `SmallVec` is extended by the difference, with eachÁü¯²a^ additional slot filled with the result of calling the closure `f`. The return values from `f`Áü•³HE will end up in the `SmallVec` in the order they have been generated.Áâ³úüê³HE If `new_len` is less than `len`, the `SmallVec` is simply truncated.Á·´úü¿´b_ This method uses a closure to create new values on every push. If you'd rather `Clone` a givenÁü¦µ`] value, use `resize`. If you want to use the `Default` trait to generate values, you can passÁü‹¶0- `Default::default()` as the second argument.ÁÀ¶úüȶB? Added for `std::vec::Vec` compatibility (added in Rust 1.33.0)Á�·ú<—·Ëtü£·)ÜtüÑ·85 let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3];ÁüŽ¸)& vec.resize_with(5, Default::default);Áü¼¸(% assert_eq!(&*vec, &[1, 2, 3, 0, 0]);Áé¸úüñ¸1. let mut vec : SmallVec<[_; 4]> = smallvec![];Á”
function.ÁŽÈút–È # ExamplesÁ©Èú<±ÈËtü½È)ÜtŒëÈ use std::mem;ÁŒ�É use std::ptr;Á—Éú|ŸÉ fn main() {Áü³É96 let mut v: SmallVec<[_; 1]> = smallvec![1, 2, 3];ÁñÉúüùÉ/, // Pull out the important parts of `v`.Áü­Ê let p = v.as_mut_ptr();ÁÔÑÊ let len = v.len();ÁüðÊ let cap = v.capacity();Áü”Ë" let spilled = v.spilled();Á»Ëú„ÃË
Reference in New Issue Copy Permalink