@@ -287,6 +287,8 @@ impl<A: Array> SmallVecData<A> {
287
287
SmallVecData { inline }
288
288
}
289
289
#[ inline]
290
+ unsafe fn into_inline ( self ) -> A { self . inline }
291
+ #[ inline]
290
292
unsafe fn heap ( & self ) -> ( * mut A :: Item , usize ) {
291
293
self . heap
292
294
}
@@ -327,6 +329,13 @@ impl<A: Array> SmallVecData<A> {
327
329
SmallVecData :: Inline ( ManuallyDrop :: new ( inline) )
328
330
}
329
331
#[ inline]
332
+ unsafe fn into_inline ( self ) -> A {
333
+ match self {
334
+ SmallVecData :: Inline ( a) => ManuallyDrop :: into_inner ( a) ,
335
+ _ => debug_unreachable ! ( ) ,
336
+ }
337
+ }
338
+ #[ inline]
330
339
unsafe fn heap ( & self ) -> ( * mut A :: Item , usize ) {
331
340
match * self {
332
341
SmallVecData :: Heap ( data) => data,
@@ -812,6 +821,22 @@ impl<A: Array> SmallVec<A> {
812
821
}
813
822
}
814
823
824
+ /// Convert the SmallVec into an `A` if possible. Otherwise return `Err(Self)`.
825
+ ///
826
+ /// This method returns `Err(Self)` if the SmallVec is too short (and the `A` contains uninitialized elements),
827
+ /// or if the SmallVec is too long (and all the elements were spilled to the heap).
828
+ pub fn into_inner ( self ) -> Result < A , Self > {
829
+ if self . spilled ( ) || self . len ( ) != A :: size ( ) {
830
+ Err ( self )
831
+ } else {
832
+ unsafe {
833
+ let data = ptr:: read ( & self . data ) ;
834
+ mem:: forget ( self ) ;
835
+ Ok ( data. into_inline ( ) )
836
+ }
837
+ }
838
+ }
839
+
815
840
/// Retains only the elements specified by the predicate.
816
841
///
817
842
/// In other words, remove all elements `e` such that `f(&e)` returns `false`.
@@ -1945,6 +1970,18 @@ mod tests {
1945
1970
assert_eq ! ( vec. into_vec( ) , vec![ 0 , 1 , 2 ] ) ;
1946
1971
}
1947
1972
1973
+ #[ test]
1974
+ fn test_into_inner ( ) {
1975
+ let vec = SmallVec :: < [ u8 ; 2 ] > :: from_iter ( 0 ..2 ) ;
1976
+ assert_eq ! ( vec. into_inner( ) , Ok ( [ 0 , 1 ] ) ) ;
1977
+
1978
+ let vec = SmallVec :: < [ u8 ; 2 ] > :: from_iter ( 0 ..1 ) ;
1979
+ assert_eq ! ( vec. clone( ) . into_inner( ) , Err ( vec) ) ;
1980
+
1981
+ let vec = SmallVec :: < [ u8 ; 2 ] > :: from_iter ( 0 ..3 ) ;
1982
+ assert_eq ! ( vec. clone( ) . into_inner( ) , Err ( vec) ) ;
1983
+ }
1984
+
1948
1985
#[ test]
1949
1986
fn test_from_vec ( ) {
1950
1987
let vec = vec ! [ ] ;
0 commit comments