boc/rust-service/target/debug/deps/libsmallvec-97fd81655f68edef.rmeta

rust
’º
#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ
‰À‘"
‚$é!»
writeÁŒï!Ìè!testsÁ,¨"‚$�"MallocShallowSizeOfÁœÄ&»
malloc_size_ofÁÔ’&MallocSizeOfÁdÙ&»

”"$MallocSizeOfOpsÁ|ç&»

”EGDeserializeÁ\ª'»
serdeÁŒ€'DeserializerÁd·'»

†"$	SeqAccessÁLÅ'»

†?AVisitorÁ<Ð'»

†Z\	SerializeÁLä'»

†wySerializeSeqÁdï'»

†—™
SerializerÁTý'»

†µ·PhantomDataÁ\º(»

†Œ”(ioÁë(»

Ê
ŒÎ(ManuallyDropÁd£)»
drain_keep_restÁÜö(DrainFilterÁ\Õm»
drain_filterÁÄñkSmallVecDataÁd³ 
»
CŒ™ 
SmallVecVisitorÁ|ߊ»

†ŒÄŠ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Á
smallvec_inlineÁ
debug_unreachableÁ
ExtendFromSliceÁ
(¥
(extend_from_sliceÁ


+¥
+
×



.×


0÷

infallibleÁ
2¥
layout_arrayÁ
4¥
4	

deallocateÁ
7¥
DrainÁ
9'aÁ
9¥
9
tail_startÁ
9tail_lenÁ
9ù
9Á


@
ñ
@¥
@×


D
ñ
D¥


G
ñ
G¥


J
ñ
J¥
J›

Jó	
N	
J	size_hintÁ


Q
ñ
Q¥
Q	next_backÁ
T	


V
ñ
V¥
V‘

	
Z
ñ
Z¥



]
ñ
]¥
]ã

ß
a’
aInlineÁ
c

cˆ
aHeapÁ
fµ
f‘


i¥
iŸ
i
i
from_constÁ
m


o’
oÝ
o
inline_mutÁ
ofrom_inlineÁ
oemptyÁ
ointo_inlineÁ
oheapÁ
oheap_mutÁ
o	from_heapÁ



y’


{’
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Á


ã

ñ
ã
’
ã
÷


ç
’
ç
÷


ê
’
ê
÷


í
’
í
š
í
°

í
Ö


ò
’
ò
š
ò
×


ö
’
ö

×


ù
’
ù
ù
û
š


ý
’
ý
extendÁ
ÿ
š

 
�’
�×

!
„’
„>

"
‡’
‡ã

#
Š’
Šƒ
Š†

$
Ž’
Ž“
Ž�

%
’’

&
”’
ӕ


'
—’
—‹

(
š’
š§
Ϫ

)
ž’
IntoIterÁ
 ’
 
¬
 currentÁ
 þ

*
¥’
¥×

+
¨’
¨ƒ

,
«’
«ã

-
®’
®›

®ó	
®
�

.
³’
³
²

/
¶’

0
¸’

1
º’
º
¸
º
È

2
¾’
¾
¶
¾›

¾ê

3
Ã
ñ
Ã’
Ã
¶
Û

Ãê

4
É
ñ
É’
É
¶
É›

Éê
M
Ï›

Ï™
SetLenOnDropÁ
Ò
ñ
Ò‘
Ò	local_lenÁ

5
Ö
ñ
Öæ	
ÖgetÁ
Ö
increment_lenÁ

6
Û
ñ
Ûã

7
Þ¥
ÞŸ
Þ
Þ	new_constÁ
Þ
ß
ã
Þfrom_const_with_len_uncheckedÁ
å

8
ç¥
çŸ
ç
ç›

ç™

ToSmallVecÁ
í’
íto_smallvecÁ

9
ð’
ð
Æ#
ConstNonNullÁ
ó

ó¥
óˆ

:
÷¥
־	
÷
ò

;
û¥
ûƒ

<
þ¥
CollectionAllocErrÁ
€CapacityOverflowÁ
�

€AllocErrÁ
ƒlayoutÁ

=
…×
*

*


-

-


/

/


/

C

C


C

N

P

T

Y

`

q

r

v

w

‰


‹


Œ


�


Ž


�


�


‘


’


•


–


—


—



™


š


›


œ


�


ž


Ÿ


 


¡


¢


£


¤


¦


§


¨


©


²


¶


¶



¸


¸



º


¼


¼



¼


¾


¾



Â


Å


Æ


É


Ê


Ê



Ë


Ë



Î


Ó


Ö


Ù


Ü


ß


â


ñ


õ


ø


ø



ÿ


ƒ

ƒ


ƒ

‰

Œ

�

�


‘

‘


–

–


™

™


œ

œ


§

§


§

ª

­

±

²

µ

¼

½

Ù

Ú

Ý

ï

ò

ý

†

†


†
(Ïí(
ªB
ªBö

­BbufÁ
÷<
®B‘
÷<
9)
-ÜnL
¥
çE
çE

èEGlobalÁ
¿±‡§í#
”+


¿c

€�

‚
ê$
ƒ
‡%


„
—%

\1¦qôÏ÷å


Äc

Ð+


é
Ð+

ûØ

ûØ


üØLayoutErrorÁ

:ð¨?
¢©


¿c

9
9
å
<
�


=
’


>ù

?Á

jf•—ïý®
ñ

¥


� 

Ú,

Ìì


Ú,

ùM

Ú,


ŒM

Ú,


ÃM

Ú,


òP

Ú,


Œ"

Ú,


Ìì


ac
d
˜

eˆ

f
°

gµ

h‘


éÀãÇ0öh

’

� 

ý-

Œ"

«

«

¸
­
¹

®

Û

¯
‘

M¶%tM,dA

”+


é!

}
}
‡

�

€

¬

:>)·5w�

É.


ö!

­/


à
­/



É.Ð


ã
­/
ù/


 
­/
ù/


£
­/
ù/


é
}
}
‡

�

€

¬

:>)·5w�


’

ñ


ç0Ð


é
­/
ªB
ªBö

­B
ê)
÷<
®B‘
÷<
9)
-ÜnL
ú/
š+


é
­/
É.


Ù¢
­/

š


³"
­/
á1

(
­/
ú/


ÃL
­/
ú/


ÐL
­/
ú/


¿c

­/


³

­/


Œ"

­/


Ø

­/


µß

­/
}
}
‡

�

€

¬

:>)·5w�


“


™

­/


íß

­/
­/


º

­/


še

­/


Ìì


­/

¿c

 
 
¶
¢
¬

£
Ö

¤þ

F�\˜[?

É.


Ø

Æ3


Œ"

Æ3


ùM

Æ3


ŒM

Æ3


ÃM

Æ3


òP

Æ3


ÇL

­/


ÇL


ñ²0


ÇL


ñ²0



Œ"

Ò
Ò
¦!
Ô‘

Õ
Ê!

0ÖäçL5_7

ñ

Ï

”+
Ÿ
í
ù/
É.


Ø

ó
ó
ô
ì#

öˆ

>Ìu)ÑÁ�²

”+


Š 

Ý5

+
ªBö

}…
€@
9�
}¥
 .
€0
ۋ

}ç

}ê

}D
9{
aG
9y
až
}J
9®
 Q
9³
 V
9¶
 Z
9¸
 ]
9°

«
‡
}«
 Û
ÒÐ

}Ô

}×

}Ú

}Ý

}à

}í

}ò

}ù

}ý

}„
}Š
}¨
 û
óŽ
}’
}”
}—
}š
}¾
}Ã

É


ç
ð
	þ
ó(À
¿c
Äc

é
� 
Ìì


ùM
ŒM
ÃM
òP
Œ"
é!
 
ö!

à

ã

 

£

Ù¢

³"

ÃL

ÐL

³

Ø
µß


™

íß


º

še

ÇLÏ
í

Š 

4¨¹
	

䓹
	a

À5

®¹

µ¹

m
üи
e
ac
d
˜

eˆ

f
°

gµ

h‘


éÀãÇ0öh

À5$„¹

ÑÛ


ÑÛ
MaybeUninitÁ

ÓÛ
uninitÁ

Ý

ÔÛ
»

Ý
Íõƒ«%9

À54ä¸

­;


Ý


Ó

üòâ/
¬‹ã	

œ‹ã




ò

À5

-
;

BÄòâ


m
”+
Ÿ

W

i ãü¼âp	}

À5Ýâ

«ã

²ã
â
ü‘â¡

}
}
‡

�

€

¬

:>)·5w�

À5$­â
×:

­;
_

üéæ1¼‚ç,“ç	



$„‚ç




ñ

À5

5

G˜ç^

eÄéæ

û<

o
‚™çü³ær	}

À5ÔæÊ=
Ÿ
¤ç
«ç
üúå±


ã

ù=$¤æÀ5,’æ
×:

­;þ
À5ü

itemsÁ(


Z

†Ê=
Ÿ
ãë	üúë1¼“ì,¤ì	



$„“ì


”?

/

A©ìX

_Äúë

û<

i
|ªìüÂët	}

À5

µì	
¼ì
üãêÙ


å

ù=$³ëÀ5,•ëÊ=¤ë
Ê=

×:

­;

À5

ï?7


‘:
v



4¥´
	a

É.



d
'
ý-2
ÑÛ


ÑÛ

¹:

ÓÛ

Î:

Ý

ÔÛ
»

Ý
Íõƒ«%9

É.w
~




´³ö	ó

”+



ô
)
Ý54
‰

‰§



‹‰

ï
íe¼îËè¿*

”+i
p


(2479a} ÏÒíóô€í




¤,×!
 
4Ø"

èØ

	LayoutErrÁLà"
Þ‚


BoxÁþ"
�

Á�#÷<

	Á


	ö
™#
ªB


Y4²#
 

ZLº#
£


‹Ð#
‹

×ß#
 `

Ž
$õ#
še

Ž

 e

‘
4û#
¢e

unreachable_uncheckedÁ¬”$
‘

repeatÁ4¼$
�K

‹
dÄ$
ÃL


FusedIteratorÁlÒ$
òP

˜
dá$
ÇL

íú$
ë


¹:\Ž%
ÑÛ


­
$«%
 

¹
,±%

�£

RangeBoundsÁ\¸%
¤#

µ$Ö%
“

 §
<Ü%

‰

!ž$ø%
‰f

#Ú
Tþ%
“k

$
ý
Dž3
%

Œ|Ã@
&
ü­ç”
ü­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)Á(2479a} ÏÒíóô€íÇ



¤È
 
Ç

èØ


ÃE½
Þ‚



àE¹
�

Á¸÷<

	ÁÊ


	ö
¸
ªB


Y·
 

Z¶
£


‹µ
‹

×´
 `

Ž
³
še

Ž
Å
 e

‘
³
¢e


¯G�
‘


×G–
�K

‹
•
ÃL


ƒH‡
òP

˜
†
ÇL

í…
ë


¹:„
ÑÛ


­
ƒ
 

¹
‚

�£


„Iv
¤#

µu
“

 §
t

‰

!žs
‰f

#Ú
r
“k

$
ý
q
%

Œp
&
éìï´Æ!ædÉ"ÝàÆÉŒð"¹,‡#­°D”#“d£#ˆ‹|LÊ#sLÙ#gTè#[^<?üˆ$!T¯$
æéÙÜLô$дƒ%ÄLŸ%·¥%«®’•LÊ%‰Ð%}€\ê%t,ð%hk¬‘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);Á<ú, # }Á<‚-
šsŠ-úüŽ-:7 - Create a [`SmallVec`] from a given element and size:ÁÉ-ú<Í-
šsüÕ-)
«sŒÿ-
Ýsü‘./, let v: SmallVec<[_; 10]> = smallvec![1; 3];ÁüÁ.1. assert_eq!(v, SmallVec::from_buf([1, 1, 1]));Á<ó.
—u<û.
šsƒ/úü‡/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û3

7‰
¬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Ì7
8®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Õ6
8ÁÈ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ä¶@üÓ7nk Creates an inline [`SmallVec`] containing the arguments. This macro is enabled by the feature `const_new`.ÁÂ8úüÆ8vs `smallvec_inline!` allows `SmallVec`s to be defined with the same syntax as array expressions in `const` contexts.Áü½9ZW The inline storage `A` will always be an array of the size specified by the arguments.Áü˜:&
‰r¿:úüÃ:@
År„;ú<ˆ;
šsü�;0- # use smallvec::{smallvec_inline, SmallVec};ÁŒÁ;
ÝsüÓ;<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);Á<Û<
—u<ã<
šsë<úüï<:
Àuª=ú<®=
šsü¶=0
ð‰
΍=
Ýsüù=96 const V: SmallVec<[i32; 3]> = smallvec_inline![1; 3];Áü³>1. assert_eq!(V, SmallVec::from_buf([1, 1, 1]));Á<å>
—u<í>
šsõ>úüù>YV Note that the behavior mimics that of array expressions, in contrast to [`smallvec`].Á
»
	const_newÁ¬Ù?ìÓ?(|¦@b"Ó@¹C

ŽA›A
�A8
¶|�A,”A8Ã•A
&–A8›$—A*�A
 A§A

7‰
¬4¡A%¨A
®AÂA
	,¯A8
�~$°A
&´A8›$µA
%¹A,»A8¹¼A
&½A8›$¾A*ÄA
ÇAŒB


ÈA‹B
,ÒA8,ÓA
'ØA8
‡DÚA
'âA

äA
åAëA
8æA
%çA,éA8¹êAìA
'íA8
ßTïA
ùA…B

úA„B
,ûA8
�~$üA
%€B,‚B8¹ƒB%�B
“B¦B
,”B
•B�B

,–B8Ã—B
&˜B8›$™B$žB
ŸB,¡B
¢B¤B


$£B-¥B*¨B
«B¶C


¬BµC
8,¶B8Ÿ¼B
&½B8¬,¿BÅB7ˆ
¬4ÇB,ÎB
ÏBóB

ÐB,ÒB8,ÓB
'ØB8
Œ|ÚB
	éB
êBòB
ëB8
¶|ìB,ðB8ÃñB
ôB
%õB,ÿB8,€C
'…C8
‡D‡C
'�C

‘C
’C—C
8“C
%”C8Ÿ–C˜C
'™C8
ßT›C
¥C¯C

¦C®C
,§C
¨C¬C

,©C8ÃªC
$«C
­C%·Cô™D
»
CŒ„DœƒDôúCŒ¦D
¸DšF

¾D¿D*ÁD
ÄD�E

8
¢ŒÎD
	ßD
àDûD
7entered unreachable codeÁÔáD%‚E
ˆE�E
,‰E8°ŠE
&‹E8›$ŒE*’E
•E—F

8ŸE8â¢E
	¥E
¦E·E
8�„§E
¹EÛE
8Á
,ÇE
	ÌE
ÍEÐE

,ÎE8°ÏE%ÑE8$ÝE
âE‘F
8
¯G¬ð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
šs
4•JlžJ|¶J(
¥)

()


Îì


ü¬J�

Íì


¨-ÆJ(

± 
)± 
/**
*&(ü�K-üÏJ96 Extends a collection from a slice of its element typeÁŒ�K

‡
ˆ
‡¹ 



ˆ
¨-

(

¢K
(
*
¹ 

¨-
$§K
¹
,­KüÓK,
¥,

,
Íì


”+ØK
Ø

”+,ÛK×*-*
- ü†L,Œ‰L

‰
Š
‰×*


Š
”+

+

›L
+
-

”+
$ L
¹
,¦Lü¹O(Ð+/
Åc
/üèO8ëO
‹
Œ
�
‹Ð+

Œ
 c

 cˆ


¢cµ


 `

£c
ê)

 `
àB¤GS


�

Ö¿
Ù¿

Ú¿«



Û¿ˆ

Ü¿

Ý¿



Þ¿ˆ

‚†f|Â



ŸÈ

ŸÈ


 ÈErrorÁ
O˜éBL

.
ïO
.
/
$ðO
±öOüóP+Ð+1
ë
1ì¥Q$¨QŸ,Ð+

0
0
1
­QüûQ<TþQ


Ö¿
Ù¿

Ú¿«



Û¿ˆ

Ü¿

Ý¿



Þ¿ˆ

‚†f|Â

”+
Ð+”+

¥3

3
Ú¢
‰R
2

”+
�4ŒRü¥UBd¨U

Ê=
Ö¿
Ù¿

Ú¿«



Û¿ˆ

Ü¿

Ý¿



Þ¿ˆ

‚†f|Â


èØ

èØ 


éØ™

²‚


êØŸ

²‚

ªë¥CHÈ
Ð+

¥5

5
Ú¢
µU
4

”+
¹¸U³W
4
<closure_kind>Á6

<closure_signature>Á6
<upvars>Á6

6
46
”+


Ÿ,Ð+

üàW9TêW
µEÊ=
¥8

8
Ú¢
õW
7

”+
µø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Á,’[

ñ:¥;

:;
Å 
œ[¨-
ñŸ[Ï

¨-,¤[

¨-Ð
ñ§e
Ú,jf•—ïý®

<=>?`˜[Z\:Œ±[T±[

9
9Ê=|È[DÈ[

9
9Ê=ôÝ[$Ý[

9
9
Äl

ÄlIterÁ

Çlµ

™l

Èl
end_or_lenÁ

™l

Él_markerÁ

™l
ŒœjSž
ñ
Þ®
�\�\

9
9
‰

‰§



‹‰

ï
íe¼îËè¿*

}
}
‡

�

€

¬

:>)·5w�

¨-üŸ\R
ñA¥B

AB
Å 
¨\¿®
«\Í®
,°\
¿c

Þ®
Tæ\Ú,C
Àc
C¤\68Aüø\8û\

Ž
�
�
ŽÚ,

�
 c

 cˆ


¢cµ


 `

£c
ê)

 `
àB¤GS


�
Ÿ¥


@
ÿ\
@
C
ñ
¨-
$€]
±†]ü�^6
ñE¥F

EF
Å 
‘^
� 

¨-$”^Í®
,›^Ú,�^$&ü»^6
ñH¥I

I
HÅ 
Ë^
Ìì


¨-$Î^Í®
,Õ^Ú,Ç^%'üö^1
ñK¥L

KL
Å 
ÿ^¿®
‚_Í®
,‡_Ú,MNP
úM
ûM
ÿMPNû^57KL®_$³_
J
JÞ®
üÖ_%$Ù_




‘
‘Ú,

Û¼
ݼ


Þ¼©


ß¼

à¼Û




Ἀ

cSñŸ«‡zÙ

Þ®


J
Þ_
J
N
ñ
¨-
$ã_\µ`
N
Ø©
O

ð©
O

�ª
O

O
NO
¨-


Þ®
Þ®


üû`-Lþ`



’
’Ú,Ê=
Û¼
ݼ


Þ¼©


ß¼

à¼Û




Ἀ

cSñŸ«‡zÙ

Ê=

J
ˆa
J
P
ñ
¨-
$‰aüÒa<
ñR¥S

RS
Å 
Ûa¿®
ÞaÍ®
,ãaÚ,T
�M
T×a&(Rü£b*L¦b




“
“Ú,
ä¶


Q
°b
Q
T
ñ
¨-
$µb\Œc
T
Ø©
U

ð©
U

�ª
U

U
TU
¨-

§¸

üÂc5
ñW¥X

X
WÅ 
ËcÍ®
,ÎcÚ,Y
ÄM
YÇc ´Œd�d



”
”Ú,Ê=

V
“d
V
Y
ñ
¨-
$”düÆd1
ñ[¥\

[\
Å 
ÏdÍ®
,ÒdÚ,Ëdüüd-
ñ^¥_

_
^Å 
…e¿®
ˆeÍ®
,�eÚ,`
�"
`�e&(^”°e$³e



•
•Ú,


]
¸e
]
`
ñ
¨-
$½e܃´

»
CŒî³
œí³
ôä³
dˆ´



’b

b
Íì


É.•´
Ï

É.,˜´
ý-éÀãÇ0öh


cdf

de§Dý-



ghBDq!q!

a

a
d

É.q!q!

§Dý-

a

aÛÀ
t¬´


a

a§D$Œµ


a

aý-¬æ¶
æ¶


a

a
‰

‰§



‹‰

ï
íe¼îËè¿*

ú/T…·
…·


a

aÊ=üÖ·
,
»
CŒ©·
œ¨·
»

ÅŽ
¬½·
ü¤·
/ü›·
:¥j
Ÿk
k
jÚ¢
Û·

ŸÊ=tÞ·
×:m
ä·
Ê=üи
8TÙ¸




­;×:

i
iû<
Ýôع

»
CŒÃ¹
œÂ¹
ô¹¹

’p

pë¿
ݹ
ü¿
,à¹
ý-qrstuvwx







!#ü‹º
04•º





–
–ý-ó
ó
ô
ì#

öˆ

>Ìu)ÑÁ�²

ú/
o

ϼ

o
q

É.
$�º
üý»
3T‡¼





—
—ý-
àÁ

o

’¼

o
r

É.
$—¼
üï½
9\ò½



§Dý-

o

o
s

É.
Ý4þ½
쳿
,¶¿




ý-

o

o
t

É.üÚÁ
-\äÁ



ý-§D
o

o
u

É.
$ðÁ
ü’Ã
7$œÃ





˜
˜ý-—Å
Ê=
o

¡Ã

o
v

É.
$¢Ã
üõÄ
?DÿÄ





™
™ý-
àÁ

™Ê=

o

ˆÅ

o
w

É.
$�Å
üÑÆ
BLÔÆ



àÁ
Ê=ý-

o

o
x

É.
µÞÆ

‘õÆ
üÇÇ
5
’z

zë¿
ÓÇ
ü¿
,ÖÇ

Ìì


É.$ÞÇ
ý-"$ü€È
5
’|

|ë¿
ŒÈ
ü¿
,�È

� 

É.$—È
ý-!#ìôÐ
üºÈ
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
 elements.ÁÐÙ
úüØÙ
QN Will create a heap allocation only if `n` is larger than the inline capacity.Á®Ú
ú<¶Ú

šsìÂÚ
 # use smallvec::SmallVec;ÁäÚ
úüìÚ
<9 let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);Á­Û
úÔµÛ
 assert!(v.is_empty());ÁüÔÛ
! assert!(v.capacity() >= 100);Á<úÛ

šsl›Ü


Ê=­/

�


�

„


É.
¹©Ü
ü¹à
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]);Á<Ÿà

šsDÀà


‰1­/

�


�

…


É.
ÁÍà
ü¾ë
&üéè
@= 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);Áéê
úüñê
.
Êß
<¤ë

šsDÅë


É.­/

�


�

†


É.

ê)Îë
ü­ð
:üôì
@
Øà
ü¹í
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);ÁØï
úüàï
.
Êß
<“ð

šs„´ð


É.Ê=­/

�


�

‡


É.

ê)Åð

‘Íð
ü�ö
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¯õ
 };缛
úüÂõ
.
Êß
<õõ

šsÔ�ö


§DÊ=­/
�


�

ˆ


É.

ê)¸ö

‘Íö
üÑù
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.Á<ßù



š
š­/
Ê=
�


çù

�

‰


É.
$ìù

new_lenÁ<òù
ì­û
|°û




Ê=

�


�

Š


É.ü­‚"üÜ�>; The maximum number of elements this vector can hold inlineÁ\´‚



›
›­/Ê=

�


À‚
�

‹


É.
$Á‚Ô¿ƒüý‚/, The number of elements stored in the vectorÁƃ



œ
œ­/Ê=

�


ʃ
�

Œ


É.
$˃ô»„üÿƒ)& Returns `true` if the vector is emptyÁD„



�
�­/

�


Ë„
�

�


É.
$Ì„üÒ…üÿ„@= The number of items the vector can hold without reallocatingÁDÙ…



ž
ž­/Ê=

�


â…
�

Ž


É.
$ã…üÀ‡94Ç




Ÿ
Ÿ­/—Å
Ê=Ê=

�


ʇ
�

�


É.
$ˇüØŠATÛŠ




 
 ­/
àÁ

 Ê=
Ê=

�


æŠ
�

�


É.
$ëŠì÷Žü“ŽQN Returns `true` if the data has spilled into a separate heap-allocated buffer.Á<þŽ



¡
¡­/

�


†�
�

‘


É.
$‡�üú“]üÒ�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ÁÖ¶ú<Þ¶
šsüê¶)& # 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, []);Á<ø¸
šs4‹¹


¥
¦
¥­/


¦Í2


�


“˜



˜


•¹
�

Íì


‚3’¹Ï

‚3¬Î¹

‚3Ðú/tÔ¹
—

É.
‚3
$š¹
¹
, ¹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`.Á$ë»


§
§­/
Ê=

�


ð»
�

™


É.
$õ»
new_capÁ<û»üÒ½LüüE
ã…�½úü•½8
À†DÙ½


¨
¨­/
Ê=
Ö¿
Ù¿

Ú¿«



Û¿ˆ

Ü¿

Ý¿



Þ¿ˆ

‚†f|Â


Ð+

�


â½
�

š


É.
$ç½

�ˆ<í½üŸÍ,ü»Ë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`.Á<¦Í



©
©­/
Ê=

�


®Í
�

›


É.
$³Í

additionalÁT¹ÍüúÎ#¬ýÎ




ª
ª­/


�


“Ï
�

œ


É.
$˜Ïü¼ÒRü¬ÑC
“ŠôÑúüüÑ;
îŠ\ÃÒ


«
«­/
Ê=þ‰

�


ÏÒ
�

�


É.
$ÔÒ

ÒŒTÚÒü†Ø2üôÖOL Reserve the minimum capacity for `additional` more elements to be inserted.ÁÈ×úüÐ×1. Panics if the new capacity overflows `usize`.Ál�Ø


¬
¬­/
Ê=

�


ݯ
�

ž


É.
$ Ø

ÒŒT¦ØüÑÙXüýØO
䎌ØÙ


­
­­/
Ê=þ‰

�


êÙ
�

Ÿ


É.
$ïÙ

ÒŒ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ŒÞ


®
®­/


�


šÞ
�

 


É.
$ŸÞüŠå&üÀâ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‘å


¯
¯­/
Ê=

�


šå
�