src/vec/vec-final.md - rust-lang/nomicon - Git at Google

 # The Final Code

 ```rust
 use std::alloc::{self, Layout};
 use std::marker::PhantomData;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::ptr::{self, NonNull};

 struct RawVec<T> {
     ptr: NonNull<T>,
     cap: usize,
 }

 unsafe impl<T: Send> Send for RawVec<T> {}
 unsafe impl<T: Sync> Sync for RawVec<T> {}

 impl<T> RawVec<T> {
     fn new() -> Self {
         // !0 is usize::MAX. This branch should be stripped at compile time.
         let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };

         // `NonNull::dangling()` doubles as "unallocated" and "zero-sized allocation"
         RawVec {
             ptr: NonNull::dangling(),
             cap,
         }
     }

     fn grow(&mut self) {
         // since we set the capacity to usize::MAX when T has size 0,
         // getting to here necessarily means the Vec is overfull.
         assert!(mem::size_of::<T>() != 0, "capacity overflow");

         let (new_cap, new_layout) = if self.cap == 0 {
             (1, Layout::array::<T>(1).unwrap())
         } else {
             // This can't overflow because we ensure self.cap <= isize::MAX.
             let new_cap = 2 * self.cap;

             // `Layout::array` checks that the number of bytes is <= usize::MAX,
             // but this is redundant since old_layout.size() <= isize::MAX,
             // so the `unwrap` should never fail.
             let new_layout = Layout::array::<T>(new_cap).unwrap();
             (new_cap, new_layout)
         };

         // Ensure that the new allocation doesn't exceed `isize::MAX` bytes.
         assert!(
             new_layout.size() <= isize::MAX as usize,
             "Allocation too large"
         );

         let new_ptr = if self.cap == 0 {
             unsafe { alloc::alloc(new_layout) }
         } else {
             let old_layout = Layout::array::<T>(self.cap).unwrap();
             let old_ptr = self.ptr.as_ptr() as *mut u8;
             unsafe { alloc::realloc(old_ptr, old_layout, new_layout.size()) }
         };

         // If allocation fails, `new_ptr` will be null, in which case we abort.
         self.ptr = match NonNull::new(new_ptr as *mut T) {
             Some(p) => p,
             None => alloc::handle_alloc_error(new_layout),
         };
         self.cap = new_cap;
     }
 }

 impl<T> Drop for RawVec<T> {
     fn drop(&mut self) {
         let elem_size = mem::size_of::<T>();

         if self.cap != 0 && elem_size != 0 {
             unsafe {
                 alloc::dealloc(
                     self.ptr.as_ptr() as *mut u8,
                     Layout::array::<T>(self.cap).unwrap(),
                 );
             }
         }
     }
 }

 pub struct Vec<T> {
     buf: RawVec<T>,
     len: usize,
 }

 impl<T> Vec<T> {
     fn ptr(&self) -> *mut T {
         self.buf.ptr.as_ptr()
     }

     fn cap(&self) -> usize {
         self.buf.cap
     }

     pub fn new() -> Self {
         Vec {
             buf: RawVec::new(),
             len: 0,
         }
     }
     pub fn push(&mut self, elem: T) {
         if self.len == self.cap() {
             self.buf.grow();
         }

         unsafe {
             ptr::write(self.ptr().add(self.len), elem);
         }

         // Can't overflow, we'll OOM first.
         self.len += 1;
     }

     pub fn pop(&mut self) -> Option<T> {
         if self.len == 0 {
             None
         } else {
             self.len -= 1;
             unsafe { Some(ptr::read(self.ptr().add(self.len))) }
         }
     }

     pub fn insert(&mut self, index: usize, elem: T) {
         assert!(index <= self.len, "index out of bounds");
         if self.len == self.cap() {
             self.buf.grow();
         }

         unsafe {
             ptr::copy(
                 self.ptr().add(index),
                 self.ptr().add(index + 1),
                 self.len - index,
             );
             ptr::write(self.ptr().add(index), elem);
         }

         self.len += 1;
     }

     pub fn remove(&mut self, index: usize) -> T {
         assert!(index < self.len, "index out of bounds");

         self.len -= 1;

         unsafe {
             let result = ptr::read(self.ptr().add(index));
             ptr::copy(
                 self.ptr().add(index + 1),
                 self.ptr().add(index),
                 self.len - index,
             );
             result
         }
     }

     pub fn drain(&mut self) -> Drain<T> {
         let iter = unsafe { RawValIter::new(&self) };

         // this is a mem::forget safety thing. If Drain is forgotten, we just
         // leak the whole Vec's contents. Also we need to do this *eventually*
         // anyway, so why not do it now?
         self.len = 0;

         Drain {
             iter,
             vec: PhantomData,
         }
     }
 }

 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {
         while let Some(_) = self.pop() {}
         // deallocation is handled by RawVec
     }
 }

 impl<T> Deref for Vec<T> {
     type Target = [T];
     fn deref(&self) -> &[T] {
         unsafe { std::slice::from_raw_parts(self.ptr(), self.len) }
     }
 }

 impl<T> DerefMut for Vec<T> {
     fn deref_mut(&mut self) -> &mut [T] {
         unsafe { std::slice::from_raw_parts_mut(self.ptr(), self.len) }
     }
 }

 impl<T> IntoIterator for Vec<T> {
     type Item = T;
     type IntoIter = IntoIter<T>;
     fn into_iter(self) -> IntoIter<T> {
         let (iter, buf) = unsafe {
             (RawValIter::new(&self), ptr::read(&self.buf))
         };

         mem::forget(self);

         IntoIter {
             iter,
             _buf: buf,
         }
     }
 }

 struct RawValIter<T> {
     start: *const T,
     end: *const T,
 }

 impl<T> RawValIter<T> {
     unsafe fn new(slice: &[T]) -> Self {
         RawValIter {
             start: slice.as_ptr(),
             end: if mem::size_of::<T>() == 0 {
                 ((slice.as_ptr() as usize) + slice.len()) as *const _
             } else if slice.len() == 0 {
                 slice.as_ptr()
             } else {
                 slice.as_ptr().add(slice.len())
             },
         }
     }
 }

 impl<T> Iterator for RawValIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<T> {
         if self.start == self.end {
             None
         } else {
             unsafe {
                 if mem::size_of::<T>() == 0 {
                     self.start = (self.start as usize + 1) as *const _;
                     Some(ptr::read(NonNull::<T>::dangling().as_ptr()))
                 } else {
                     let old_ptr = self.start;
                     self.start = self.start.offset(1);
                     Some(ptr::read(old_ptr))
                 }
             }
         }
     }

     fn size_hint(&self) -> (usize, Option<usize>) {
         let elem_size = mem::size_of::<T>();
         let len = (self.end as usize - self.start as usize)
                   / if elem_size == 0 { 1 } else { elem_size };
         (len, Some(len))
     }
 }

 impl<T> DoubleEndedIterator for RawValIter<T> {
     fn next_back(&mut self) -> Option<T> {
         if self.start == self.end {
             None
         } else {
             unsafe {
                 if mem::size_of::<T>() == 0 {
                     self.end = (self.end as usize - 1) as *const _;
                     Some(ptr::read(NonNull::<T>::dangling().as_ptr()))
                 } else {
                     self.end = self.end.offset(-1);
                     Some(ptr::read(self.end))
                 }
             }
         }
     }
 }

 pub struct IntoIter<T> {
     _buf: RawVec<T>, // we don't actually care about this. Just need it to live.
     iter: RawValIter<T>,
 }

 impl<T> Iterator for IntoIter<T> {
     type Item = T;
     fn next(&mut self) -> Option<T> {
         self.iter.next()
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
 }

 impl<T> DoubleEndedIterator for IntoIter<T> {
     fn next_back(&mut self) -> Option<T> {
         self.iter.next_back()
     }
 }

 impl<T> Drop for IntoIter<T> {
     fn drop(&mut self) {
         for _ in &mut *self {}
     }
 }

 pub struct Drain<'a, T: 'a> {
     vec: PhantomData<&'a mut Vec<T>>,
     iter: RawValIter<T>,
 }

 impl<'a, T> Iterator for Drain<'a, T> {
     type Item = T;
     fn next(&mut self) -> Option<T> {
         self.iter.next()
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.iter.size_hint()
     }
 }

 impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
     fn next_back(&mut self) -> Option<T> {
         self.iter.next_back()
     }
 }

 impl<'a, T> Drop for Drain<'a, T> {
     fn drop(&mut self) {
         // pre-drain the iter
         for _ in &mut *self {}
     }
 }
 #
 # fn main() {
 #     tests::create_push_pop();
 #     tests::iter_test();
 #     tests::test_drain();
 #     tests::test_zst();
 #     println!("All tests finished OK");
 # }
 #
 # mod tests {
 #     use super::*;
 #
 #     pub fn create_push_pop() {
 #         let mut v = Vec::new();
 #         v.push(1);
 #         assert_eq!(1, v.len());
 #         assert_eq!(1, v[0]);
 #         for i in v.iter_mut() {
 #             *i += 1;
 #         }
 #         v.insert(0, 5);
 #         let x = v.pop();
 #         assert_eq!(Some(2), x);
 #         assert_eq!(1, v.len());
 #         v.push(10);
 #         let x = v.remove(0);
 #         assert_eq!(5, x);
 #         assert_eq!(1, v.len());
 #     }
 #
 #     pub fn iter_test() {
 #         let mut v = Vec::new();
 #         for i in 0..10 {
 #             v.push(Box::new(i))
 #         }
 #         let mut iter = v.into_iter();
 #         let first = iter.next().unwrap();
 #         let last = iter.next_back().unwrap();
 #         drop(iter);
 #         assert_eq!(0, *first);
 #         assert_eq!(9, *last);
 #     }
 #
 #     pub fn test_drain() {
 #         let mut v = Vec::new();
 #         for i in 0..10 {
 #             v.push(Box::new(i))
 #         }
 #         {
 #             let mut drain = v.drain();
 #             let first = drain.next().unwrap();
 #             let last = drain.next_back().unwrap();
 #             assert_eq!(0, *first);
 #             assert_eq!(9, *last);
 #         }
 #         assert_eq!(0, v.len());
 #         v.push(Box::new(1));
 #         assert_eq!(1, *v.pop().unwrap());
 #     }
 #
 #     pub fn test_zst() {
 #         let mut v = Vec::new();
 #         for _i in 0..10 {
 #             v.push(())
 #         }
 #
 #         let mut count = 0;
 #
 #         for _ in v.into_iter() {
 #             count += 1
 #         }
 #
 #         assert_eq!(10, count);
 #     }
 # }
 ```
	# The Final Code

	```rust
	use std::alloc::{self, Layout};
	use std::marker::PhantomData;
	use std::mem;
	use std::ops::{Deref, DerefMut};
	use std::ptr::{self, NonNull};

	struct RawVec<T> {
	ptr: NonNull<T>,
	cap: usize,
	}

	unsafe impl<T: Send> Send for RawVec<T> {}
	unsafe impl<T: Sync> Sync for RawVec<T> {}

	impl<T> RawVec<T> {
	fn new() -> Self {
	// !0 is usize::MAX. This branch should be stripped at compile time.
	let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };

	// `NonNull::dangling()` doubles as "unallocated" and "zero-sized allocation"
	RawVec {
	ptr: NonNull::dangling(),
	cap,
	}
	}

	fn grow(&mut self) {
	// since we set the capacity to usize::MAX when T has size 0,
	// getting to here necessarily means the Vec is overfull.
	assert!(mem::size_of::<T>() != 0, "capacity overflow");

	let (new_cap, new_layout) = if self.cap == 0 {
	(1, Layout::array::<T>(1).unwrap())
	} else {
	// This can't overflow because we ensure self.cap <= isize::MAX.
	let new_cap = 2 * self.cap;

	// `Layout::array` checks that the number of bytes is <= usize::MAX,
	// but this is redundant since old_layout.size() <= isize::MAX,
	// so the `unwrap` should never fail.
	let new_layout = Layout::array::<T>(new_cap).unwrap();
	(new_cap, new_layout)
	};

	// Ensure that the new allocation doesn't exceed `isize::MAX` bytes.
	assert!(
	new_layout.size() <= isize::MAX as usize,
	"Allocation too large"
	);

	let new_ptr = if self.cap == 0 {
	unsafe { alloc::alloc(new_layout) }
	} else {
	let old_layout = Layout::array::<T>(self.cap).unwrap();
	let old_ptr = self.ptr.as_ptr() as *mut u8;
	unsafe { alloc::realloc(old_ptr, old_layout, new_layout.size()) }
	};

	// If allocation fails, `new_ptr` will be null, in which case we abort.
	self.ptr = match NonNull::new(new_ptr as *mut T) {
	Some(p) => p,
	None => alloc::handle_alloc_error(new_layout),
	};
	self.cap = new_cap;
	}
	}

	impl<T> Drop for RawVec<T> {
	fn drop(&mut self) {
	let elem_size = mem::size_of::<T>();

	if self.cap != 0 && elem_size != 0 {
	unsafe {
	alloc::dealloc(
	self.ptr.as_ptr() as *mut u8,
	Layout::array::<T>(self.cap).unwrap(),
	);
	}
	}
	}
	}

	pub struct Vec<T> {
	buf: RawVec<T>,
	len: usize,
	}

	impl<T> Vec<T> {
	fn ptr(&self) -> *mut T {
	self.buf.ptr.as_ptr()
	}

	fn cap(&self) -> usize {
	self.buf.cap
	}

	pub fn new() -> Self {
	Vec {
	buf: RawVec::new(),
	len: 0,
	}
	}
	pub fn push(&mut self, elem: T) {
	if self.len == self.cap() {
	self.buf.grow();
	}

	unsafe {
	ptr::write(self.ptr().add(self.len), elem);
	}

	// Can't overflow, we'll OOM first.
	self.len += 1;
	}

	pub fn pop(&mut self) -> Option<T> {
	if self.len == 0 {
	None
	} else {
	self.len -= 1;
	unsafe { Some(ptr::read(self.ptr().add(self.len))) }
	}
	}

	pub fn insert(&mut self, index: usize, elem: T) {
	assert!(index <= self.len, "index out of bounds");
	if self.len == self.cap() {
	self.buf.grow();
	}

	unsafe {
	ptr::copy(
	self.ptr().add(index),
	self.ptr().add(index + 1),
	self.len - index,
	);
	ptr::write(self.ptr().add(index), elem);
	}

	self.len += 1;
	}

	pub fn remove(&mut self, index: usize) -> T {
	assert!(index < self.len, "index out of bounds");

	self.len -= 1;

	unsafe {
	let result = ptr::read(self.ptr().add(index));
	ptr::copy(
	self.ptr().add(index + 1),
	self.ptr().add(index),
	self.len - index,
	);
	result
	}
	}

	pub fn drain(&mut self) -> Drain<T> {
	let iter = unsafe { RawValIter::new(&self) };

	// this is a mem::forget safety thing. If Drain is forgotten, we just
	// leak the whole Vec's contents. Also we need to do this eventually
	// anyway, so why not do it now?
	self.len = 0;

	Drain {
	iter,
	vec: PhantomData,
	}
	}
	}

	impl<T> Drop for Vec<T> {
	fn drop(&mut self) {
	while let Some(_) = self.pop() {}
	// deallocation is handled by RawVec
	}
	}

	impl<T> Deref for Vec<T> {
	type Target = [T];
	fn deref(&self) -> &[T] {
	unsafe { std::slice::from_raw_parts(self.ptr(), self.len) }
	}
	}

	impl<T> DerefMut for Vec<T> {
	fn deref_mut(&mut self) -> &mut [T] {
	unsafe { std::slice::from_raw_parts_mut(self.ptr(), self.len) }
	}
	}

	impl<T> IntoIterator for Vec<T> {
	type Item = T;
	type IntoIter = IntoIter<T>;
	fn into_iter(self) -> IntoIter<T> {
	let (iter, buf) = unsafe {
	(RawValIter::new(&self), ptr::read(&self.buf))
	};

	mem::forget(self);

	IntoIter {
	iter,
	_buf: buf,
	}
	}
	}

	struct RawValIter<T> {
	start: *const T,
	end: *const T,
	}

	impl<T> RawValIter<T> {
	unsafe fn new(slice: &[T]) -> Self {
	RawValIter {
	start: slice.as_ptr(),
	end: if mem::size_of::<T>() == 0 {
	((slice.as_ptr() as usize) + slice.len()) as *const _
	} else if slice.len() == 0 {
	slice.as_ptr()
	} else {
	slice.as_ptr().add(slice.len())
	},
	}
	}
	}

	impl<T> Iterator for RawValIter<T> {
	type Item = T;
	fn next(&mut self) -> Option<T> {
	if self.start == self.end {
	None
	} else {
	unsafe {
	if mem::size_of::<T>() == 0 {
	self.start = (self.start as usize + 1) as *const _;
	Some(ptr::read(NonNull::<T>::dangling().as_ptr()))
	} else {
	let old_ptr = self.start;
	self.start = self.start.offset(1);
	Some(ptr::read(old_ptr))
	}
	}
	}
	}

	fn size_hint(&self) -> (usize, Option<usize>) {
	let elem_size = mem::size_of::<T>();
	let len = (self.end as usize - self.start as usize)
	/ if elem_size == 0 { 1 } else { elem_size };
	(len, Some(len))
	}
	}

	impl<T> DoubleEndedIterator for RawValIter<T> {
	fn next_back(&mut self) -> Option<T> {
	if self.start == self.end {
	None
	} else {
	unsafe {
	if mem::size_of::<T>() == 0 {
	self.end = (self.end as usize - 1) as *const _;
	Some(ptr::read(NonNull::<T>::dangling().as_ptr()))
	} else {
	self.end = self.end.offset(-1);
	Some(ptr::read(self.end))
	}
	}
	}
	}
	}

	pub struct IntoIter<T> {
	_buf: RawVec<T>, // we don't actually care about this. Just need it to live.
	iter: RawValIter<T>,
	}

	impl<T> Iterator for IntoIter<T> {
	type Item = T;
	fn next(&mut self) -> Option<T> {
	self.iter.next()
	}
	fn size_hint(&self) -> (usize, Option<usize>) {
	self.iter.size_hint()
	}
	}

	impl<T> DoubleEndedIterator for IntoIter<T> {
	fn next_back(&mut self) -> Option<T> {
	self.iter.next_back()
	}
	}

	impl<T> Drop for IntoIter<T> {
	fn drop(&mut self) {
	for _ in &mut *self {}
	}
	}

	pub struct Drain<'a, T: 'a> {
	vec: PhantomData<&'a mut Vec<T>>,
	iter: RawValIter<T>,
	}

	impl<'a, T> Iterator for Drain<'a, T> {
	type Item = T;
	fn next(&mut self) -> Option<T> {
	self.iter.next()
	}
	fn size_hint(&self) -> (usize, Option<usize>) {
	self.iter.size_hint()
	}
	}

	impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
	fn next_back(&mut self) -> Option<T> {
	self.iter.next_back()
	}
	}

	impl<'a, T> Drop for Drain<'a, T> {
	fn drop(&mut self) {
	// pre-drain the iter
	for _ in &mut *self {}
	}
	}
	#
	# fn main() {
	# tests::create_push_pop();
	# tests::iter_test();
	# tests::test_drain();
	# tests::test_zst();
	# println!("All tests finished OK");
	# }
	#
	# mod tests {
	# use super::*;
	#
	# pub fn create_push_pop() {
	# let mut v = Vec::new();
	# v.push(1);
	# assert_eq!(1, v.len());
	# assert_eq!(1, v[0]);
	# for i in v.iter_mut() {
	# *i += 1;
	# }
	# v.insert(0, 5);
	# let x = v.pop();
	# assert_eq!(Some(2), x);
	# assert_eq!(1, v.len());
	# v.push(10);
	# let x = v.remove(0);
	# assert_eq!(5, x);
	# assert_eq!(1, v.len());
	# }
	#
	# pub fn iter_test() {
	# let mut v = Vec::new();
	# for i in 0..10 {
	# v.push(Box::new(i))
	# }
	# let mut iter = v.into_iter();
	# let first = iter.next().unwrap();
	# let last = iter.next_back().unwrap();
	# drop(iter);
	# assert_eq!(0, *first);
	# assert_eq!(9, *last);
	# }
	#
	# pub fn test_drain() {
	# let mut v = Vec::new();
	# for i in 0..10 {
	# v.push(Box::new(i))
	# }
	# {
	# let mut drain = v.drain();
	# let first = drain.next().unwrap();
	# let last = drain.next_back().unwrap();
	# assert_eq!(0, *first);
	# assert_eq!(9, *last);
	# }
	# assert_eq!(0, v.len());
	# v.push(Box::new(1));
	# assert_eq!(1, *v.pop().unwrap());
	# }
	#
	# pub fn test_zst() {
	# let mut v = Vec::new();
	# for _i in 0..10 {
	# v.push(())
	# }
	#
	# let mut count = 0;
	#
	# for _ in v.into_iter() {
	# count += 1
	# }
	#
	# assert_eq!(10, count);
	# }
	# }
	```