From b4f873191903087f4fb69195b73dcfcda008e113 Mon Sep 17 00:00:00 2001 From: Ivan Date: Wed, 13 Jun 2018 12:25:59 +0200 Subject: [PATCH] Fixed compilation on latest nightly locally, but still issue on playground side --- src/vec-final.md | 190 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 140 insertions(+), 50 deletions(-) diff --git a/src/vec-final.md b/src/vec-final.md index 199528a..9033e40 100644 --- a/src/vec-final.md +++ b/src/vec-final.md @@ -5,11 +5,11 @@ #![feature(allocator_api)] #![feature(unique)] -use std::ptr::{Unique, self}; +use std::alloc::{oom, Global, GlobalAlloc, Layout}; +use std::marker::PhantomData; use std::mem; use std::ops::{Deref, DerefMut}; -use std::marker::PhantomData; -use std::alloc::{GlobalAlloc, Layout, Global, oom}; +use std::ptr::{self, Unique}; struct RawVec { ptr: Unique, @@ -22,7 +22,10 @@ impl RawVec { let cap = if mem::size_of::() == 0 { !0 } else { 0 }; // Unique::empty() doubles as "unallocated" and "zero-sized allocation" - RawVec { ptr: Unique::empty(), cap: cap } + RawVec { + ptr: Unique::empty(), + cap: cap, + } } fn grow(&mut self) { @@ -38,15 +41,17 @@ impl RawVec { (1, ptr) } else { let new_cap = 2 * self.cap; - let ptr = Global.realloc(self.ptr.as_ptr() as *mut _, - Layout::array::(self.cap).unwrap(), - Layout::array::(new_cap).unwrap().size()); + let ptr = Global.realloc( + self.ptr.as_ptr() as *mut _, + Layout::array::(self.cap).unwrap(), + Layout::array::(new_cap).unwrap().size(), + ); (new_cap, ptr) }; // If allocate or reallocate fail, oom if ptr.is_null() { - oom() + oom(Layout::array::(self.cap).unwrap()) } self.ptr = Unique::new_unchecked(ptr as *mut _); @@ -60,8 +65,10 @@ impl Drop for RawVec { let elem_size = mem::size_of::(); if self.cap != 0 && elem_size != 0 { unsafe { - Global.dealloc(self.ptr.as_ptr() as *mut _, - Layout::array::(self.cap).unwrap()); + Global.dealloc( + self.ptr.as_ptr() as *mut _, + Layout::array::(self.cap).unwrap(), + ); } } } @@ -73,15 +80,24 @@ pub struct Vec { } impl Vec { - fn ptr(&self) -> *mut T { self.buf.ptr.as_ptr() } + fn ptr(&self) -> *mut T { + self.buf.ptr.as_ptr() + } - fn cap(&self) -> usize { self.buf.cap } + fn cap(&self) -> usize { + self.buf.cap + } pub fn new() -> Self { - Vec { buf: RawVec::new(), len: 0 } + Vec { + buf: RawVec::new(), + len: 0, + } } pub fn push(&mut self, elem: T) { - if self.len == self.cap() { self.buf.grow(); } + if self.len == self.cap() { + self.buf.grow(); + } unsafe { ptr::write(self.ptr().offset(self.len as isize), elem); @@ -96,21 +112,23 @@ impl Vec { None } else { self.len -= 1; - unsafe { - Some(ptr::read(self.ptr().offset(self.len as isize))) - } + unsafe { Some(ptr::read(self.ptr().offset(self.len as isize))) } } } pub fn insert(&mut self, index: usize, elem: T) { assert!(index <= self.len, "index out of bounds"); - if self.cap() == self.len { self.buf.grow(); } + if self.cap() == self.len { + self.buf.grow(); + } unsafe { if index < self.len { - ptr::copy(self.ptr().offset(index as isize), - self.ptr().offset(index as isize + 1), - self.len - index); + ptr::copy( + self.ptr().offset(index as isize), + self.ptr().offset(index as isize + 1), + self.len - index, + ); } ptr::write(self.ptr().offset(index as isize), elem); self.len += 1; @@ -122,9 +140,11 @@ impl Vec { unsafe { self.len -= 1; let result = ptr::read(self.ptr().offset(index as isize)); - ptr::copy(self.ptr().offset(index as isize + 1), - self.ptr().offset(index as isize), - self.len - index); + ptr::copy( + self.ptr().offset(index as isize + 1), + self.ptr().offset(index as isize), + self.len - index, + ); result } } @@ -169,24 +189,16 @@ impl Drop for Vec { impl Deref for Vec { type Target = [T]; fn deref(&self) -> &[T] { - unsafe { - ::std::slice::from_raw_parts(self.ptr(), self.len) - } + unsafe { ::std::slice::from_raw_parts(self.ptr(), self.len) } } } impl DerefMut for Vec { fn deref_mut(&mut self) -> &mut [T] { - unsafe { - ::std::slice::from_raw_parts_mut(self.ptr(), self.len) - } + unsafe { ::std::slice::from_raw_parts_mut(self.ptr(), self.len) } } } - - - - struct RawValIter { start: *const T, end: *const T, @@ -202,7 +214,7 @@ impl RawValIter { slice.as_ptr() } else { slice.as_ptr().offset(slice.len() as isize) - } + }, } } } @@ -227,8 +239,8 @@ impl Iterator for RawValIter { fn size_hint(&self) -> (usize, Option) { let elem_size = mem::size_of::(); - let len = (self.end as usize - self.start as usize) - / if elem_size == 0 { 1 } else { elem_size }; + let len = + (self.end as usize - self.start as usize) / if elem_size == 0 { 1 } else { elem_size }; (len, Some(len)) } } @@ -250,9 +262,6 @@ impl DoubleEndedIterator for RawValIter { } } - - - pub struct IntoIter { _buf: RawVec, // we don't actually care about this. Just need it to live. iter: RawValIter, @@ -260,12 +269,18 @@ pub struct IntoIter { impl Iterator for IntoIter { type Item = T; - fn next(&mut self) -> Option { self.iter.next() } - fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } + fn next(&mut self) -> Option { + self.iter.next() + } + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } } impl DoubleEndedIterator for IntoIter { - fn next_back(&mut self) -> Option { self.iter.next_back() } + fn next_back(&mut self) -> Option { + self.iter.next_back() + } } impl Drop for IntoIter { @@ -274,9 +289,6 @@ impl Drop for IntoIter { } } - - - pub struct Drain<'a, T: 'a> { vec: PhantomData<&'a mut Vec>, iter: RawValIter, @@ -284,12 +296,18 @@ pub struct Drain<'a, T: 'a> { impl<'a, T> Iterator for Drain<'a, T> { type Item = T; - fn next(&mut self) -> Option { self.iter.next_back() } - fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } + fn next(&mut self) -> Option { + self.iter.next() + } + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } } impl<'a, T> DoubleEndedIterator for Drain<'a, T> { - fn next_back(&mut self) -> Option { self.iter.next_back() } + fn next_back(&mut self) -> Option { + self.iter.next_back() + } } impl<'a, T> Drop for Drain<'a, T> { @@ -299,5 +317,77 @@ impl<'a, T> Drop for Drain<'a, T> { } } -# fn main() {} +#[cfg(test)] +mod tests { + use super::*; + #[test] + 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, 1); + let x = v.pop(); + assert_eq!(Some(2), x); + assert_eq!(1, v.len()); + v.push(10); + let x = v.remove(0); + assert_eq!(1, x); + assert_eq!(1, v.len()); + } + + #[test] + 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); + } + + #[test] + 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()); + } + + #[test] + 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); + } +} + +#[allow(dead_code)] +fn main() {} ```