270 lines
117 KiB
Plaintext
270 lines
117 KiB
Plaintext
|
rust
|
|||
|
|
¸Ò #rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥! -3d1337db07d0b3aeÁ ¤²XctÔ'ÐÓ©z¨É½Ó -a4945860e1c53b00Á ¤°ð ¾ä-±($²ï=©Ã -7e98a21bfd32b0edÁ serdeÁFV æ¸Û•IÄÀz Í -9c8ce3cf08540cc3Á À뉊 ]!ÜÛê(¹Þ—šên -5be7b69c3ff7b5b8Á –�òÖÀH•‘P IÓ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Ór2Ù $¨ûib‚ -cf21ca6f2bb15dcdÁë
|
|||
|
|
‹ás «LÖ€îâƒ×ɯŒ -ee6f3747e38367f0Á serde_deriveÁ,w|êñ]ù¿¥C£ð -975c43f96d83014eÁ
|
|||
|
|
serde_coreÁ²€Ãb˜ cÐòÅ�¾ÇÇ
|
|||
|
|
-7a42419d8e43b208Á À ‘" ‚ $é! » writeÁŒï! Ìè! testsÁ,¨" ‚ $�" MallocShallowSizeOfÁœÄ& » malloc_size_ofÁÔ’& MallocSizeOfÁdÙ& »¼ "$ MallocSizeOfOpsÁ|ç& »¼ EG ioÁë( »òŒÎ( ManuallyDropÁd£) » drain_keep_restÁÜö( 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œú »Ë UW EncodeÁ4¯ú »Ë pr EncoderÁ<·ú »Ë ŒŽ WriterÁ4Çú »Ë §© DecodeErrorÁ\Üú »Ë ÇÉ EncodeErrorÁ\éú »Ë çé BorrowDecodeÁdûú »Ë í ¤
|
|||
|
|
|
|||
|
|
! " # $ % & ' ( ) * + , smallvecÁ smallvec_inlineÁ debug_unreachableÁ ExtendFromSliceÁ 3¥ 3 extend_from_sliceÁ 6¥ 6Š 9× ;÷
|
|||
|
|
infallibleÁ =¥ layout_arrayÁ ?¥ ?
|
|||
|
|
deallocateÁ B¥ DrainÁ D 'aÁ D¥ D
|
|||
|
|
tail_startÁ D tail_lenÁ Dù DÁ K¤ K¥ K× O¤ O¥ R¤ R¥ U¤ U¥ U› Uó Y U size_hintÁ \¤ \¥ \ next_backÁ _ a¤ a¥ a‘ e¤ e¥
|
|||
|
|
h¤ h¥ hã � l’ l InlineÁ n
|
|||
|
|
nˆ l HeapÁ qµ q‘ t¥ tŸ t t
|
|||
|
|
from_constÁ x z’ zÝ z
|
|||
|
|
inline_mutÁ z from_inlineÁ z emptyÁ z into_inlineÁ z heapÁ z heap_mutÁ z 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⤠⒠âÂ% â› âê 7è¤ è’ èÂ% è› èê M î› î™ SetLenOnDropÁ ñ¤ ñ‘ ñ local_lenÁ 8õ¤ õæ õ getÁ õ
|
|||
|
|
increment_lenÁ 9ú¤ úã :ý¥ ýŸ ý ý new_constÁ ý’ ‚ ý from_const_with_len_uncheckedÁ „ ;†¥ †Ÿ † †› †™
|
|||
|
|
ToSmallVecÁ Œ’ Œ to_smallvecÁ <�’ �Ò* ConstNonNullÁ ’
|
|||
|
|
’¥ ’ˆ =–¥ –æ –ª >š¥ šƒ ?�¥ CollectionAllocErrÁ Ÿ CapacityOverflowÁ
|
|||
|
|
Ÿ AllocErrÁ ¢ layoutÁ @¤× 5
|
|||
|
|
5
|
|||
|
|
8
|
|||
|
|
8
|
|||
|
|
:
|
|||
|
|
:
|
|||
|
|
:
|
|||
|
|
N
|
|||
|
|
N
|
|||
|
|
N
|
|||
|
|
Y
|
|||
|
|
[
|
|||
|
|
_
|
|||
|
|
d
|
|||
|
|
k
|
|||
|
|
|
|
|||
|
|
}
|
|||
|
|
�
|
|||
|
|
‚
|
|||
|
|
”
|
|||
|
|
–
|
|||
|
|
—
|
|||
|
|
˜
|
|||
|
|
™
|
|||
|
|
š
|
|||
|
|
›
|
|||
|
|
œ
|
|||
|
|
�
|
|||
|
|
|
|||
|
|
¡
|
|||
|
|
¢
|
|||
|
|
¢
|
|||
|
|
¤
|
|||
|
|
¥
|
|||
|
|
¦
|
|||
|
|
§
|
|||
|
|
¨
|
|||
|
|
©
|
|||
|
|
ª
|
|||
|
|
«
|
|||
|
|
¬
|
|||
|
|
|
|||
|
|
®
|
|||
|
|
¯
|
|||
|
|
±
|
|||
|
|
²
|
|||
|
|
³
|
|||
|
|
´
|
|||
|
|
½
|
|||
|
|
Á
|
|||
|
|
Á
|
|||
|
|
Ã
|
|||
|
|
Ã
|
|||
|
|
Å
|
|||
|
|
Ç
|
|||
|
|
Ç
|
|||
|
|
Ç
|
|||
|
|
É
|
|||
|
|
É
|
|||
|
|
Í
|
|||
|
|
Ð
|
|||
|
|
Ñ
|
|||
|
|
Ô
|
|||
|
|
Õ
|
|||
|
|
Õ
|
|||
|
|
Ö
|
|||
|
|
Ö
|
|||
|
|
Ù
|
|||
|
|
Þ
|
|||
|
|
á
|
|||
|
|
ä
|
|||
|
|
ç
|
|||
|
|
ê
|
|||
|
|
í
|
|||
|
|
ð
|
|||
|
|
þ
|
|||
|
|
þ
|
|||
|
|
þ
|
|||
|
|
�
|
|||
|
|
”
|
|||
|
|
—
|
|||
|
|
—
|
|||
|
|
ž
|
|||
|
|
¢
|
|||
|
|
¢
|
|||
|
|
¢
|
|||
|
|
¨
|
|||
|
|
«
|
|||
|
|
¬
|
|||
|
|
¬
|
|||
|
|
°
|
|||
|
|
°
|
|||
|
|
µ
|
|||
|
|
µ
|
|||
|
|
¸
|
|||
|
|
¸
|
|||
|
|
»
|
|||
|
|
»
|
|||
|
|
Æ
|
|||
|
|
Æ
|
|||
|
|
Æ
|
|||
|
|
É
|
|||
|
|
Ì
|
|||
|
|
Ð
|
|||
|
|
Ñ
|
|||
|
|
Ô
|
|||
|
|
Û
|
|||
|
|
Ü
|
|||
|
|
ø
|
|||
|
|
ù
|
|||
|
|
ü
|
|||
|
|
Ž
|
|||
|
|
‘
|
|||
|
|
œ
|
|||
|
|
¥
|
|||
|
|
¥
|
|||
|
|
¥
|
|||
|
|
3îŒ 3ªBªB ö B bufÁ÷< ®B‘÷< 9)
|
|||
|
|
-ÜnL ¥çEçEèE GlobalÁ ¿±‡§í# ¶2 ¿c Ÿ ¡ö+ ¢ “, ££, £À{ƒ)2Û Äcò2 é ò2ûØûØüØ LayoutErrorÁ :ð¨?¢© ¿c D D ˜ G´ HÅ Iù JÁ Eç’“oó"y ¤¥ � ü3 Ììü3 ùMü3 ŒMü3 ÃMü3 òPü3 Œ"ü3 Ìì l n oË pˆ q ã rµ s‘ OŽRT¥É‰t ’ � Ÿ5 Œ" ¶ ¶ 𠸹 ¹“ º‘ ¢óÏ>ç#’¶2 é! ˆ ˆ ¼ ŠÔ ‹ä ñI˜êiP�ë5 ö!Ï6 à Ï6
|
|||
|
|
ë5 ï ã Ï6ž7 Ï6ž7 £Ï6ž7 ÙAÏ6 û; ˆ ˆ ¼ ŠÔ ‹ä ñI˜êiP�’ ó Ì< ÷ ÷ ! ù¿! rσÇKHÇ™8 ó é á7 ¤
|
|||
|
|
™8 ï é Ï6ªBªB ö BŒ1÷< ®B‘÷< 9)
|
|||
|
|
-ÜnLŸ7¼2 é Ï6ë5 Ù¢Ï6š ³"Ï6à9 3Ï6Ÿ7 ÃLÏ6Ÿ7 ÐLÏ6Ÿ7 ¿cÏ6 ³ Ï6 Œ"Ï6 ØÏ6 µßÏ6 ˆ ˆ ¼ ŠÔ ‹ä ñI˜êiP�“ ™Ï6 íßÏ6Ï6 ºÏ6 šeÏ6 ÌìÏ6 ¿c ¿ ¿ Â% Áä Ââ% Ãþ Á|pÞGØ-Ðë5 ØÈ; Œ"È; ùMÈ; ŒMÈ; ÃMÈ; òPÈ; ÇLÏ6 ÇL ¤á7 ÇL ¤á7 Œ" ñ ñ ²( ó‘ ôÖ( Ë2è
|
|||
|
|
:� ¤ î¶2 Ÿ Œž7ë5 Ø ’ ’ “ø* •ˆ 2Q=Ô8
|
|||
|
|
V¶2 Š ß= 6ªB• ˆ¤ ŸK D ˆÄ ¿9 Ÿ; Ÿ‚ ˆ† ˆ‰ ˆO D† lR D„ l½ ˆU DÍ ¿\ DÒ ¿a DÕ ¿e D× ¿h D» ¶¦ ˆÊ ¿ú ñÛ ˆß ˆâ ˆå ˆè ˆë ˆî ˆò ˆú ÷Œ ˆ‘ ˆ˜ ˆœ ˆ£ ˆ© ˆÇ ¿š ’ ˆ± ˆ³ ˆ¶ ˆ¹ ˆÝ ˆâ
|
|||
|
|
è
|
|||
|
|
†� � ’ 3ð¿c
|
|||
|
|
Äcé � Ìì ùMŒM ÃM òP Œ" é!!ö!à ã £ÙAû;Ì<Ù¢³"ÃLÐL³ صߙíߺšeÇL î ŒŠ 4¨¹ 䓹 l Â= ®¹ µ¹ x üиe l n oË pˆ q ã rµ s‘ OŽRT¥É‰tÂ= $„¹ ÑÛÑÛ MaybeUninitÁ ÓÛ uninitÁÝ ÔÛ»Ý Íõƒ«%9Â= 4ä¸ îC Ý Ó üòâ/ ¬‹ã
|
|||
|
|
œ‹ã
|
|||
|
|
òÂ= - ;
|
|||
|
|
B Äòâ
|
|||
|
|
x¶2 Ÿ W i ã ü¼âp ˆ Â= Ýâ «ã ²ã � ü‘â¡ ˆ ˆ ¼ ŠÔ ‹ä ñI˜êiP�Â= $â ˜C îC b üéæ1 ¼‚ç ,“ç
|
|||
|
|
$ „‚ç
|
|||
|
|
ñÂ= 5 G ˜ç ^
|
|||
|
|
e Äéæ ¼E o ‚ ™ç ü³ær ˆ Â= Ôæ ŒF Ÿ ¤ç «ç üúå± ‚ »F $¤æ Â= ,’æ ˜C îC ÿ Â= ý itemsÁ( Z† ŒF Ÿ ãë üúë1 ¼“ì ,¤ì
|
|||
|
|
$ „“ì ÙG / A ©ì X
|
|||
|
|
_ Äúë ¼E i | ªì üÂët ˆ Â= µì ¼ì üãêÙ „ »F $³ë Â= ,•ë ŒF ¤ë ŒF ˜C îC Â= µH7 ‘: v 4¥´ l ë5 o ' Ÿ5 2 ÑÛÑÛ úB ÓÛ�CÝ ÔÛ»Ý Íõƒ«%9ë5 w ~ ´³ö ’ ¶2 “ ) ß= 4 ‰‰ § ‹‰ ï íe¼îËè¿*¶2 i p 3=?BDlˆ÷¿îñŒ’“Ÿí ¤,×! 4Ø" èØ LayoutErrÁLà" Þ‚ BoxÁ þ" � Á �# ÷< Á ö ™# ªB
|
|||
|
|
Y4²# ZLº# £
|
|||
|
|
‹ Ð# ‹ × ß# ` Ž$õ# še Ž e ‘4û# ¢e unreachable_uncheckedÁ¬”$ ‘ repeatÁ4¼$ �K ‹dÄ$ ÃL
|
|||
|
|
FusedIteratorÁlÒ$ òP ˜dá$ ÇL í ú$ ë úB\Ž% ÑÛ
|
|||
|
|
$«%  ¹,±% �£ RangeBoundsÁ\¸% ¤# µ $Ö% “ §<Ü% ‰ !ž$ø% ‰f #ÚTþ% “k $ DeserializeÁ\ª' û; ' DeserializerÁd·' ˆ< ( SeqAccessÁLÅ' ‹= ) VisitorÁ<Ð' Ì< * SerializeÁLä' ÙA , SerializeSeqÁdï' ’B -
|
|||
|
|
SerializerÁTý' ÜA . PhantomDataÁ\º( • /ƒT – /°Dž3 0 ¿|Ã@ 1 üç” ü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Á è ú üìK H By default, `smallvec` does not depend on `std`. However, the optionalÁ ü¸N K `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.Á ü M J 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.Á ý
|
|||
|
|
ú ü�Z W 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`Á ¶ ú üº( ýc ã ú üç¶ ³ 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Á ü·Z W [Rust Reference](https://doc.rust-lang.org/reference/const_eval.html#const-functions).Á ’ ú ´– ### `drain_filter`Á ú ü±f c **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`Á ô ú üøi f **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`Á ´ ú ü¸T Q **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.)Á ñ ú üõZ W Tracking issue: [rust-lang/rust#31844](https://github.com/rust-lang/rust/issues/31844)Á Ð ú ¤Ô ### `may_dangle`Á é ú üíT ÿm  ú üÆ_ \ This feature makes the Rust compiler less strict about use of vectors that contain borrowedÁ ü¦ $ ! references. For details, see theÁ üË Y V [Rustonomicon](https://doc.rust-lang.org/1.42.0/nomicon/dropck.html#an-escape-hatch).Á ¥ ú ü© Z W Tracking issue: [rust-lang/rust#34761](https://github.com/rust-lang/rust/issues/34761)Á 3=?BDlˆ÷¿îñŒ’“ŸíÆ ¤Ç Æ èØ �N¼ Þ‚ ªN¸ � Á· ÷< ÁÉ ö· ªB
|
|||
|
|
Y¶ Zµ £
|
|||
|
|
‹´ ‹ ׳ ` Ž² še ŽÄ e ‘² ¢e ùOœ ‘ ¡P• �K ‹” ÃL ÍP† òP ˜… ÇL í„ ë úBƒ ÑÛ
|
|||
|
|
‚  ¹� �£ ÎQu ¤# µ t “ §s ‰ !žr ‰f #Úq “k $¸Re û; 'ÖRX ˆ< (õRN ‹= )‘SF Ì< *«S< ÙA ,ÇS/ ’B -æS$ ÜA .ƒT • /ƒT* – /° 0 ¿ 1 Œ�’´Æ! ‰dÉ" €ƒilŒð" \,‡# PSD”# 6d£# +. "LÊ# LÙ#
|
|||
|
|
Tè# þßâüˆ$! ÂT¯$ °³£¦‰Œ|Lô$ s´ƒ% gLŸ% Z ¥% NQ58LÊ% , Ð% #\ê% ,ð% ,˜' |˜' ûþâåÌϸ»ü˜'I §ªŽ‘wz̬( c¬‘3 ü²)4 1 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() {Á üû+3 0 let v: SmallVec<[_; 128]> = smallvec![1, 2, 3];Á į, assert_eq!(v[0], 1);Á ÄÈ, assert_eq!(v[1], 2);Á Äá, assert_eq!(v[2], 3);Á <ú, # }Á <‚- Å Š- ú üŽ-: 7 - Create a [`SmallVec`] from a given element and size:Á É- ú <Í- Å üÕ-) Ö Œÿ- ˆ€ ü‘./ , let v: SmallVec<[_; 10]> = smallvec![1; 3];Á üÁ.1 . assert_eq!(v, SmallVec::from_buf([1, 1, 1]));Á <ó. Â� <û. Å ƒ/ ú ü‡/H E Note that unlike array expressions this syntax supports all elementsÁ üÐ/K H which implement [`Clone`] and the number of elements doesn't have to beÁ |œ0 a constant.Á ¬0 ú ü°0N K This will use `clone` to duplicate an expression, so one should be carefulÁ üÿ0J G using this with types having a nonstandard `Clone` implementation. ForÁ üÊ1O L example, `smallvec![Rc::new(1); 5]` will create a vector of five referencesÁ üš2R O to the same boxed integer value, not five references pointing to independentlyÁ œí2 boxed integers.Á (|�3 §3 Ð7 â3 ï3 ã3 8 oneÁ ä3 , è3 8à é3 & ê3 8› $ë3 *ñ3 ô3 û3 7‰¬4õ3 % ü3 ‚4 ƒ4 *…4 ˆ4 ®4 , ’4 8 ,“4 '˜4 8¼ Dš4 '¢4 8æ ¤4 §4 ¨4 % ¯4 µ4 É4 , ¶4 8 elemÁ $·4 & »4 8› $¼4 % À4 , Â4 8¹ Ã4 & Ä4 8› $Å4 *Ë4 Î4 …5 Ï4 „5 , Ù4 8 ,Ú4 'ß4 8¼ Dá4 'é4 8£ Lë4 ô4 þ4 , õ4 8½Š $ö4 $ ú4 , ü4 8¹ ý4 % †5 Œ5 ž5 , �5 Ž5 –5 , �5 8à �5 & ‘5 8› $’5 $ —5 ˜5 , ™5 š5 œ5 $ ›5 - �5 * 5 £5 Í7 ¤5 Ì7 8 ®5 8ü ,²5 ¸5 7ˆ¬4º5 , Á5 Â5 ß5 Ã5 , Å5 8 ,Æ5 'Ë5 8° DÍ5 Õ5 Ö5 Þ5 ×5 8㈠Ø5 , Ü5 8à Ý5 à5 % á5 8 ë5 8 ï5 8Á ó5 ÷5 , ù5 8 ,ú5 'ÿ5 8¼ D�6 '‰6 8æ ‹6 Ž6 �6 % �6 8 š6 8ü ,�6 £6 8Á ¦6 ©6 8™ \ª6 µ6 ¶6 ¸6 ð6 , Æ6 Ç6 Õ6 8Á È6 Ë6 8• $Ì6 Ð6 Ó6 , Ñ6 8à Ò6 % Ô6
|
|||
|
|
Ö6 8Á ä6 8 $ò6 ÷6 Æ7 , …7 8 ,†7 '‹7 8¼ D�7 '•7 8™ D—7 Ÿ7 ¼7 , 7 8 ,¡7 '¦7 8¤ ,¨7 '7 8Á ¯7 ²7 ³7 »7 , ´7 µ7 ¹7 , ¶7 8à ·7 $ ¸7 º7 % Î7 ä¶@ üÓ7n k Creates an inline [`SmallVec`] containing the arguments. This macro is enabled by the feature `const_new`.Á Â8 ú üÆ8v s `smallvec_inline!` allows `SmallVec`s to be defined with the same syntax as array expressions in `const` contexts.Á ü½9Z W The inline storage `A` will always be an array of the size specified by the arguments.Á ü˜:& ´~ ¿: ú üÃ:@ ð~ „; ú <ˆ; Å ü�;0 - # use smallvec::{smallvec_inline, SmallVec};Á ŒÁ; ˆ€ üÓ;< 9 const V: SmallVec<[i32; 3]> = smallvec_inline![1, 2, 3];Á Ä�< assert_eq!(V[0], 1);Á Ä©< assert_eq!(V[1], 2);Á ÄÂ< assert_eq!(V[2], 3);Á <Û< Â� <ã< Å ë< ú üï<: ë� ª= ú <®= Å ü¶=0 Ÿ– Œç= ˆ€ üù=9 6 const V: SmallVec<[i32; 3]> = smallvec_inline![1; 3];Á ü³>1 . assert_eq!(V, SmallVec::from_buf([1, 1, 1]));Á <å> Â� <í> Å õ> ú üù>Y V Note that the behavior mimics that of array expressions, in contrast to [`smallvec`].Á » const_newÁ¬Ù? ìÓ? (|¦@ P# Ó@ ¹C ŽA ›A �A 8ã
|
|||
|
|
,ÇE ÌE ÍE ÐE , ÎE 8° ÏE % ÑE 8 $ÝE âE ‘F 8ùO ¬ðE …F †F % ‡F % ˜F ä¬J ü�FM J 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 ú üÁG6 3 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 ú ü…I3 0 let mut small_vec = SmallVec::<[u8; 8]>::new();Á ü¹I initialize(&mut small_vec);Á üÙI- * assert_eq!(&small_vec as &[_], b"Test!");Á <‡J Å 4•J lžJ |¶J 3 ¥ 4 3 4 Îì ü¬J� ÍìÊ4 ÆJ 3 é¬) é¬/55 5 &( ü�K- üÏJ9 6 Extends a collection from a slice of its element typeÁŒ�K ¦ § ¦ñ¬ §
|
|||
|
|
Ê4 3 ¢K 3
|
|||
|
|
5ñ¬Ê4$§K ¹
|
|||
|
|
,K üÓK, ¥ 7 7 Íì¶2 ØK ض2 ,ÛK ù18 5 8 ü†L, Œ‰L ¨ © ¨ù1 ©
|
|||
|
|
¶2 6 ›L 6
|
|||
|
|
8¶2$ L ¹
|
|||
|
|
,¦L ü¹O( ò2: Åc : üèO8 ëO ª « ¬ ªò2 « c c ˆ ¢cµ
|
|||
|
|
` £cŒ1 ` àB¤GS
|
|||
|
|
¬Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ŸÈŸÈ È ErrorÁ O˜éBL 9 ïO 9
|
|||
|
|
: $ðO ± öO üóP+ ò2< ë < ì¥Q $¨Q Á3ò2 ; ;
|
|||
|
|
< Q üûQ< TþQ Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
¶2ò2¶2 ¥ > > ’¯ ‰R
|
|||
|
|
=¶2� 4ŒR ü¥UB d¨U ŒFÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
èØèØ éØ™²‚ êØŸ²‚ ªë¥CHÈ ò2 ¥ @ @ ’¯ µU
|
|||
|
|
?¶2¹ ¸U ³W ? <closure_kind>Á A <closure_signature>Á A <upvars>Á A A ? A¶2 Á3ò2 üàW9 TêW üMŒF ¥ C C ’¯ õW
|
|||
|
|
B¶2µ øW ÔD‰X ü‡[# ü×YR O 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Á ,’[ ¤ E ¥ F E F ý¬ œ[ Ê4 ¤Ÿ[ îÊ4 ,¤[ Ê4 ï ¤§eü3 Eç’“oó"y GHIJ k˜[ Z\ EŒ±[ T±[ D D ŒF|È[ DÈ[ D D ŒFôÝ[ $Ý[ D D ÄlÄl IterÁ Çlµ ™l Èl
|
|||
|
|
end_or_lenÁ™l Él _markerÁ™l ŒœjSž ¤–»Ì�\ �\ D D ‰‰ § ‹‰ ï íe¼îËè¿* ˆ ˆ ¼ ŠÔ ‹ä ñI˜êiP�Ê4üŸ\R ¤ L ¥ M M L ý¬ ¨\ ÷º«\ …»,°\ ¿c–» Tæ\ ü3N Àc N ¤\ 68 Lüø\8 û\ ® ¯ ü3 ® c c ˆ ¢cµ
|
|||
|
|
` £cŒ1 ` àB¤GS
|
|||
|
|
¯×± K ÿ\ K
|
|||
|
|
N ¤Ê4$€] ± †] ü�^6 ¤ P ¥ Q P Q ý¬ ‘^ � Ê4 $”^ …»,›^ ü3 �^ $& ü»^6 ¤ S ¥ T T S ý¬ Ë^ ÌìÊ4 $Î^ …»,Õ^ ü3 Ç^ %' üö^1 ¤ V ¥ W V W ý¬ ÿ^ ÷º‚_ …»,‡_ ü3XY[ úM ûM ÿM [ Y û^ 57 VL®_ $³_ U U –»üÖ_% $Ù_ ° °ü3ۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙ–» U Þ_ U
|
|||
|
|
Y ¤Ê4$ã_ \µ` Y�¶ Z ¨¶ Z Ŷ Z Z Y Z Ê4 –» –» üû`- Lþ` ± ±ü3 ŒFۼݼ޼© ß¼ à¼ÛἈ cSñŸ«‡zÙŒF U ˆa U
|
|||
|
|
[ ¤Ê4$‰a üÒa< ¤ ] ¥ ^ ] ^ ý¬ Ûa ÷ºÞa …»,ãa ü3_ �M _ ×a &( ]ü£b* L¦b ² ²ü3ŸÃ \ °b \
|
|||
|
|
_ ¤Ê4$µb \Œc _�¶ ` ¨¶ ` Ŷ ` ` _ ` Ê4âÄ üÂc5 ¤ b ¥ c b c ý¬ Ëc …»,Îc ü3d ÄM d Çc ´Œd �d ³ ³ü3 ŒF a “d a
|
|||
|
|
d ¤Ê4$”d üÆd1 ¤ f ¥ g g f ý¬ Ïd …»,Òd ü3 Ëd üüd- ¤ i ¥ j i j ý¬ …e ÷ºˆe …»,�e ü3k �" k �e &( i”°e $³e ´ ´ü3 h ¸e h
|
|||
|
|
k ¤Ê4$½e ܃´ »CŒî³ œí³ ôä³ dˆ´ ’ m m Íìë5 •´ îë5 ,˜´ Ÿ5 OŽRT¥É‰tnoq o p îLŸ5 rsBD ¸% ¸% l l
|
|||
|
|
oë5¸%¸% îLŸ5 l l –Ít¬´ l l îL$Œµ l l Ÿ5¬æ¶ æ¶ l l ‰‰ § ‹‰ ï íe¼îËè¿*Ÿ7T…· …· l l ŒFüÖ·, »CŒ©· œ¨· »ùš¬½· ü¤·/ ü›·: ¥ u Ÿ v u v ’¯ Û· ŸŒFtÞ· ˜Cx ä· ŒFüи8 TÙ¸ îC˜C t t ¼EÝÀ!ôع »CŒÃ¹ œÂ¹ ô¹¹ ’ { { ¦Ì ݹ ·Ì,๠Ÿ5|}~€�‚ƒ %' ü‹º0 4•º µ µŸ5 ’ ’ “ø* •ˆ 2Q=Ô8
|
|||
|
|
VŸ7 z œº z
|
|||
|
|
|ë5$�º üý»3 T‡¼ ¶ ¶Ÿ5›Î z ’¼ z
|
|||
|
|
}ë5$—¼ üï½9 \ò½ îLŸ5 z z
|
|||
|
|
~ë5Ý4þ½ 쳿 ,¶¿ Ÿ5 z z
|
|||
|
|
ë5üÚÁ- \äÁ Ÿ5îL z z
|
|||
|
|
€ë5$ðÁ ü’Ã7 $œÃ · ·Ÿ5 ÖÑŒF z ¡Ã z
|
|||
|
|
�ë5$¢Ã üõÄ? DÿÄ ¸ ¸Ÿ5›Î ¸ŒF z ˆÅ z
|
|||
|
|
‚ë5$�Å üÑÆB LÔÆ ›ÎŒFŸ5 z z
|
|||
|
|
ƒë5µ ÞÆ ‘ õÆ üÇÇ5 ’ … … ¦Ì ÓÇ ·Ì,ÖÇ Ììë5 $ÞÇ Ÿ5 "$ ü€È5 ’ ‡ ‡ ¦Ì ŒÈ ·Ì,�È � ë5 $—È Ÿ5 !# ìôÐ üºÈL I 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Á üÈÊW T `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;Á ü‚ÎI F let mut v = SmallVec::<[u8; 4]>::new(); // initialize an empty vectorÁ ÌÎ ú üÐÎH E // 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 the buffer to spill:Á t§Ð v.push(4);Á ܶРassert_eq!(v.len(), 5);Á ÌÒÐ assert!(v.spilled());Á <ìÐ Å DÿÐ ’ ‰ ‰ ¦Ì ˆÑ ·Ì,‹Ñ Ï6 ñI˜êiP� Š‹ ¨,. |™Ô D™Ô ˆ ˆ ŒF¬®Ô $®Ô ˆ ˆ Ÿ5ÔÈÔ ’ � � ¦Ì ÍÔ ·Ì,ÐÔ Ï6Ž��‘’“”•–—˜™š›œ� ¡¢¤¥¦§¨©ª«¬®¯±²³´¾¿ÀÁÃÅÇÉÍÏÐÑ ž Ü™Õ ìéÔ Construct an empty vectorÁ Õ Ï6 Œ Œ
|
|||
|
|
Žë5ü”Ü& üãØV S Construct an empty vector with enough capacity pre-allocated to store at least `n`Á l¾Ù
|
|||
|
|
elements.Á ÐÙ ú üØÙQ N Will create a heap allocation only if `n` is larger than the inline capacity.Á ®Ú ú <¶Ú Å ìÂÚ # use smallvec::SmallVec;Á äÚ ú üìÚ< 9 let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);Á Û ú ÔµÛ assert!(v.is_empty());Á üÔÛ! assert!(v.capacity() >= 100);Á <úÛ Ål›Ü ŒFÏ6 Œ Œ
|
|||
|
|
�ë5¹ ©Ü ü¹à5 ü“Ý5 2 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]);Á <Ÿà ÅDÀà ˆ9Ï6 Œ Œ
|
|||
|
|
�ë5Á Íà ü¾ë& üéè@ = Constructs a new `SmallVec` on the stack from an `A` withoutÁ ¬®é copying elements.Á Èé ú \Ðé ›§ Üàé ±Ý €ê ú ôˆê let buf = [1, 2, 3, 4, 5];Á ü«ê9 6 let small_vec: SmallVec<_> = SmallVec::from_buf(buf);Á éê ú üñê. ˜ì <¤ë ÅDÅë ë5Ï6 Œ Œ
|
|||
|
|
‘ë5Œ1 Îë üð: üôì@ ¦í ü¹í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];Á ü�ïD A let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);Á Øï ú üàï. ˜ì <“ð Å„´ð ë5ŒFÏ6 Œ Œ
|
|||
|
|
’ë5Œ1 Åð ‘ Íð ü�ö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 {Á üäôF C SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)Á 4¯õ };Á ºõ ú üÂõ. ˜ì <õõ ÅÔ�ö îLŒFÏ6 Œ Œ
|
|||
|
|
“ë5Œ1 ¸ö ‘ Íö üÑù0 üß÷ Sets the length of a vector.Á „ø ú üŒøE B This will explicitly set the size of the vector, without actuallyÁ üÖøG D modifying its buffers, so it is up to the caller to ensure that theÁ ü¢ù* ' vector is actually the specified size.Á<ßù ¹ ¹Ï6ŒF Œ çù Œ
|
|||
|
|
”ë5$ìù new_lenÁ<òù ìû |°û ŒF Œ Œ
|
|||
|
|
•ë5ü‚" üÜ�> ; The maximum number of elements this vector can hold inlineÁ\´‚ º ºÏ6 ŒF Œ À‚ Œ
|
|||
|
|
–ë5$Á‚ Ô¿ƒ üý‚/ , The number of elements stored in the vectorÁ ƃ » »Ï6 ŒF Œ ʃ Œ
|
|||
|
|
—ë5$˃ ô»„ üÿƒ) & Returns `true` if the vector is emptyÁD„ ¼ ¼Ï6 Œ Ë„ Œ
|
|||
|
|
˜ë5$Ì„ üÒ… üÿ„@ = The number of items the vector can hold without reallocatingÁDÙ… ½ ½Ï6 ŒF Œ â… Œ
|
|||
|
|
™ë5$ã… üÀ‡9 4Ç ¾ ¾Ï6 ÖÑŒFŒF Œ ʇ Œ
|
|||
|
|
šë5$ˇ üØŠA TÛŠ ¿ ¿Ï6›Î ¿ŒFŒF Œ æŠ Œ
|
|||
|
|
›ë5$ëŠ ì÷Ž ü“ŽQ N Returns `true` if the data has spilled into a separate heap-allocated buffer.Á<þŽ À ÀÏ6 Œ †� Œ
|
|||
|
|
œë5$‡� üú“] üÒ�N K Creates a draining iterator that removes the specified range in the vectorÁ ü¥�! and yields the removed items.Á Ë� ú üÓ�E B Note 1: The element range is removed even if the iterator is onlyÁ ü�‘. + partially consumed or not consumed at all.Á Б ú üØ‘K H Note 2: It is unspecified how many
|
|||
|
|
# ExampleÁ Ö¶ ú <Þ¶ Å üê¶) & # use smallvec::{SmallVec, smallvec};Á ü˜·8 5 let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];Á üÕ·8 5 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, []);Á <ø¸ Å4‹¹ Ä Å ÄÏ6 ÅÌ: Œ“ £ £ •¹ Œ Íì„; ’¹ î„; ¬Î¹ „; ï Ÿ7tÔ¹
|
|||
|
|
¢ë5„;$š¹ ¹
|
|||
|
|
, ¹ CE üä»& ü›ºE B Re-allocate to set the capacity to `max(new_cap, inline_size())`.Á åº ú üíº8 5 Panics if `new_cap` is less than the vector's lengthÁ üª»5 2 or if the capacity computation overflows `usize`.Á$ë» Æ ÆÏ6ŒF Œ ð» Œ
|
|||
|
|
¤ë5$õ» new_capÁ<û» üÒ½L üüE ±’ �½ ú ü•½8 Ž“DÙ½ Ç ÇÏ6ŒFÖ¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ò2 Œ â½ Œ
|
|||
|
|
¥ë5$ç½ Þ”<í½ üŸÍ, ü»ËC @ Reserve capacity for `additional` more elements to be inserted.Á ƒÌ ú ü‹Ì; 8 May reserve more space to avoid frequent reallocations.Á ËÌ ú üÓÌ9 6 Panics if the capacity computation overflows `usize`.Á<¦Í È ÈÏ6ŒF Œ ®Í Œ
|
|||
|
|
¦ë5$³Í
|
|||
|
|
additionalÁT¹Í üúÎ# ¬ýÎ É ÉÏ6 Œ “Ï Œ
|
|||
|
|
§ë5$˜Ï ü¼ÒR ü¬ÑC á– ôÑ ú üüÑ; ¼—\ÃÒ Ê ÊÏ6ŒFÌ– Œ ÏÒ Œ
|
|||
|
|
¨ë5$ÔÒ ™TÚÒ ü†Ø2 üôÖO L Reserve the minimum capacity for `additional` more elements to be inserted.Á È× ú üÐ×1 . Panics if the new capacity overflows `usize`.Ál�Ø Ë ËÏ6ŒF Œ ›Ø Œ
|
|||
|
|
©ë5$ Ø ™T¦Ø üÑÙX üýØO ²›ŒØÙ Ì ÌÏ6ŒFÌ– Œ êÙ Œ
|
|||
|
|
ªë5$ïÙ ™TõÙ ü…Þ üÎÜ: 7 Shrink the capacity of the vector as much as possible.Á �Ý ú ü•ÝZ W When possible, this will move data from an external heap buffer to the vector's inlineÁ dôÝ storage.ÁlŒÞ Í ÍÏ6 Œ šÞ Œ
|
|||
|
|
«ë5$ŸÞ üŠå& üÀâO L Shorten the vector, keeping the first `len` elements and dropping the rest.Á ”ã ú üœãQ N If `len` is greater than or equal to the vector's current length, this has noÁ \òã effect.Á ‚ä ú üŠäQ N This does not re-allocate. If you want the vector's capacity to shrink, callÁ üàä% " `shrink_to_fit` after truncating.ÁD‘å Î ÎÏ6ŒF Œ šå Œ
|
|||
|
|
¬ë5$Ÿå ‘ ¥å üÓè$ üôç2 / Extracts a slice containing the entire vector.Á «è ú ܳè Equivalent to `&s[..]`.ÁDÚè Ï ÏÏ6 Ïž7 Œ ãè Œ
|
|||
|
|
ë5$äè üõé0 ü’é2 / Extracts a mutable slice of the entire vector.Á Éé ú üÑé Equivalent to `&mut s[..]`.Ádüé Ð ÐÏ6 О7 Œ ‰ê Œ
|
|||
|
|
®ë5$Žê ü”ì6 üÀêO L 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.Á\›ì Ñ ÑÏ6ŒFŸ7 Œ §ì Œ
|
|||
|
|
¯ë5$¬ì Ö,²ì ½í ¯�¶ ° ¨¶ ° Ŷ ° ° ¯ °ë5 Ÿ7 ¼ªî üïí( % Remove all elements from the vector.Á,±î Ò ÒÏ6 Œ ·î Œ
|
|||
|
|
±ë5$¼î üŒð1 üéî\ Y Remove and return the element at position `index`, shifting all elements after it to theÁ LÊï left.Á Øï ú üàï' �©4“ð Ó ÓÏ6ŒFŸ7 Œ šð Œ
|
|||
|
|
²ë5$Ÿð Ö,¥ð ü¤ô8 üŸóW T Insert an element at position `index`, shifting all elements after it to the right.Á ûó ú äƒô Panics if `index > len`.Á4«ô Ô ÔÏ6ŒFŸ7 Œ ²ô Œ
|
|||
|
|
³ë5$·ô Ö,½ô elementÁ<Ëô ü�üY ü û\ Y Insert multiple elements at position `index`, shifting all following elements toward theÁ L�ü back.Á\–ü Õ ÕÏ6ŒFà9 Œš µ µ Ãü Œ Íìà9 ¢ü ÇLà9 ä¥ü à9ÈL Ÿ7t²ü
|
|||
|
|
´ë5à9$Èü Ö,Îü iterableÁDÜü TV ¬úŽ \�� ¥ · · ’¯ �� ‚6 ¢óÏ>ç#’ ¸¹º ½%' lž� ,ž� ¶ ¶ ¶2”¹� $¹� ¶ ¶ �£�£ ¹ ƒ£¹ „£þ -'ºˆÉ¬gŒFT�� �� ¶ ¶ ŒFü¯� ¥ ¼ ¼ ’¯ ´� ‚6½ �" ½ ”Ý� $à� Ö Ö‚6 » å� »
|
|||
|
|
½¶2$ê� üŽ”) ü““d a Convert a `SmallVec` to a `Vec`, without reallocating if the `SmallVec` has already spilled ontoÁ lü“
|
|||
|
|
the heap.ÁD•” Ï6ˆ9 Œ Œ
|
|||
|
|
¾ë5$¢” üƘ/ ü†—f c 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.Á„͘ Ï6�� žªN ¡ˆˆ ¢‰ˆ l }.xÏž7¼2 Œ Œ
|
|||
|
|
¿ë5$Þ˜ üÜ›* ü®™Q N Convert the `SmallVec` into an `A` if possible. Otherwise return `Err(Self)`.Á „š ú üŒšq n This method returns `Err(Self)` if the `SmallVec` is too short (and the `A` contains uninitialized elements),Á ü‚›U R or if the `SmallVec` is too long (and all the elements were spilled to the heap).ÁTã› Ï6Ö¿Ù¿ Ú¿« Û¿ˆ Ü¿ Ý¿Þ¿ˆ ‚†f|Â
|
|||
|
|
ë5Ï6 Œ Œ
|
|||
|
|
Àë5$î› üÚ B üáž9 6 Retains only the elements specified by the predicate.Á ŸŸ ú ü§ŸN K In other words, remove all elements `e` such that `f(&e)` returns `false`.Á üúŸI F This method operates in place and preserves the order of the retainedÁ lÈ ßå4á Ø ØÏ6— Œ—   ˆ¡ Œ Íì§Á è × “"§Á ן7 Üë × §ÁöÁ˜" $‚¡
|
|||
|
|
Áë5§Á$�¡ ± —¡ bd üÅ¥B ü¸£9 ù½ ö£ ú üþ£L I This method is identical in behaviour to [`retain`]; it is included onlyÁ üϤH E to maintain api-compatibility with `std::Vec`, where the methods areÁ üœ¥$ ! separate for historical reasons.ÁTÌ¥ Ú ÚÏ6§Á Œ— Ä Ä ÷¥ Œ ÔÁ ×¥ Ù “"§Á ÙŸ7 ÜÚ¥ Ù §Á¼Å˜" $ñ¥
|
|||
|
|
Ãë5§Á$ü¥ ± ‚¦ bd üܦF ü¬¦+ ( Removes consecutive duplicate elements.Á,ã¦ Û ÛÏ6 Œ é¦ Œ µßŸ7Ÿ7 ”�§
|
|||
|
|
Åë5$î¦ 4¿§ Å�¶ Æ ¨¶ Æ Å¶ Æ Æ Å Æë5 Ÿ7 Ÿ7 ü¬¨q üÚ§M J Removes consecutive duplicate elements using the given equality relation.ÁD³¨ Þ ÞÏ6§Á Œ— È È ¿¨ Œ ÔÁ ¼¨ Ü Ý “"§Á ÜŸ7 ÝŸ7 üó¨) Ü Ý §Á‹Ê˜" $˜©
|
|||
|
|
Çë5§Á$Ĩ same_bucketÁ\Ψ „† ü¼¯x üý®: 7 Removes consecutive elements that map to the same key.Ádï à àÏ6§Á Œ— Ê œ Ë Ë Ê Ö¯ Œ ÔÁ Я Íìœ Ó¯ ß “"§Á ߟ7 Ä‚° ß §Áâ̘" ÆÌ ™° µßÆÌÆÌ d§°
|
|||
|
|
Éë5§ÁÆÌ$Û¯ keyÁ å¯ •— Ž� 4Ñ° É�¶ Ì ¨¶ Ì Å¶ Ì Ì É Ìë5§ÁÆÌ”È §Áü£º_ üö°H E 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`Á ü•³H E will end up in the `SmallVec` in the order they have been generated.Á â³ ú üê³H E 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)Á �· ú <—· Å ü£·) Ö üÑ·8 5 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Á ©È ú <±È Å ü½È) Ö ŒëÈ use std::mem;Á Œ�É use std::ptr;Á —É ú |ŸÉ fn main() {Á ü³É9 6 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();Á »Ë ú „ÃË
|
|||
|
|
unsafe {Á üØËH E // Forget all about `v`. The heap allocation that stored theÁ ü¥Ì1 . // three values won't be deallocated.Á ÜÛÌ mem::forget(v);Á ûÌ ú üƒÍ/ , // Overwrite memory with [4, 5, 6].Á t·Í //Á üÊÍH E // This is only safe if `spilled` is true! Otherwise, we areÁ ü—ÎF C // writing into the old `SmallVec`'s inline storage on theÁ ¬âÎ // stack.Á ìüÎ assert!(spilled);Á ìžÏ for i in 0..len {Á üÀÏ, ) ptr::write(p.add(i), 4 + i);Á lñÏ
|
|||
|
|
}Á ƒÐ ú ü‹ÐL I // Put everything back together into a SmallVec with a differentÁ üÜÐL I // amount of inline storage, but which is still less than `cap`.Á üÑJ G let rebuilt = SmallVec::<[_; 2]>::from_raw_parts(p, len, cap);Á üüÑ. + assert_eq!(&*rebuilt, &[4, 5, 6]);Á L¯Ò }Á ,½Ò ã¨tãÒ Ÿ7ŒFŒFÏ6 Œ Œ
|
|||
|
|
Ïë5µ òÒ lengthÁ4…Ó ÔD”Ó ü¯×& üùÖ1 . Returns a raw pointer to the vector's buffer.Á4¶× â âÏ6 Ÿ7 Œ ½× Œ
|