arrayvec - cargo Package Compare versions

Comparing version 0.1.1 to 0.1.2

VERSION

+arrayvec - 0.1.2

Cargo.toml

 [package]
 name = "arrayvec"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["bluss"]
@@ -5,0 +5,0 @@ license = "MIT/Apache-2.0"

src/lib.rs

@@ -11,5 +11,3 @@ use std::iter;
 // extra traits
-use std::convert::From;
 use std::borrow::{Borrow, BorrowMut};
-use std::convert::{AsRef, AsMut};
 use std::hash::{Hash, Hasher};
@@ -19,6 +17,6 @@ use std::fmt;
 /// Make sure the non-nullable pointer optimization does not occur!
+#[repr(u8)]
 enum Flag<T> {
+    Dropped,
     Alive(T),
-    Dropped,
-    _Unused,
 }
@@ -49,6 +47,7 @@
             unsafe fn new() -> [T; $len] { mem::uninitialized() }
-            #[inline]
+            #[inline(always)]
             fn as_ptr(&self) -> *const T { self as *const _ as *const _ }
+            #[inline(always)]
             fn as_mut_ptr(&mut self) -> *mut T { self as *mut _ as *mut _}
-            #[inline]
+            #[inline(always)]
             fn capacity() -> usize { $len }
@@ -84,4 +83,4 @@ }
 pub struct ArrayVec<A: Array> {
+    xs: Flag<A>,
     len: u8,
-    xs: Flag<A>,
 }
@@ -330,2 +329,3 @@
 
+    #[inline]
     fn next(&mut self) -> Option<A::Item> {
@@ -343,4 +343,27 @@ if self.index == self.v.len {
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.v.len() - self.index as usize;
+        (len, Some(len))
+    }
 }
 
+impl<A: Array> DoubleEndedIterator for IntoIter<A> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A::Item> {
+        if self.index == self.v.len {
+            None
+        } else {
+            unsafe {
+                self.v.len -= 1;
+                let len = self.v.len();
+                let elt = ptr::read(self.v.get_unchecked_mut(len));
+                Some(elt)
+            }
+        }
+    }
+}
+
+impl<A: Array> ExactSizeIterator for IntoIter<A> { }
+
 impl<A: Array> Drop for IntoIter<A> {
@@ -448,2 +471,13 @@ fn drop(&mut self) {
 #[test]
+fn test_iter() {
+    let mut iter = ArrayVec::from([1, 2, 3]).into_iter();
+    assert_eq!(iter.size_hint(), (3, Some(3)));
+    assert_eq!(iter.next_back(), Some(3));
+    assert_eq!(iter.next(), Some(1));
+    assert_eq!(iter.next_back(), Some(2));
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.next_back(), None);
+}
+
+#[test]
 fn test_drop() {
@@ -513,1 +547,20 @@ use std::rc::Rc;
 }
+
+#[test]
+fn test_no_nonnullable_opt() {
+    // Make sure `Flag` does not apply the non-nullable pointer optimization
+    // as Option would do.
+    assert!(mem::size_of::<Flag<&i32>>() > mem::size_of::<&i32>());
+    assert!(mem::size_of::<Flag<Vec<i32>>>() > mem::size_of::<Vec<i32>>());
+}
+
+#[test]
+fn test_compact_size() {
+    // 4 elements size + 1 len + 1 enum tag + [1 drop flag]
+    type ByteArray = ArrayVec<[u8; 4]>;
+    assert!(mem::size_of::<ByteArray>() <= 7);
+
+    // 12 element size + 1 len + 1 drop flag + 2 padding + 1 enum tag + 3 padding
+    type QuadArray = ArrayVec<[u32; 3]>;
+    assert!(mem::size_of::<QuadArray>() <= 20);
+}

No alert changes

No metric changes